sanlu_new/sanlu_c#/SunRoxmServer/SunRoxm.BizPeri.ReportDataSet/SunRoxm.BizPeri.ReportDataSet.ReportDataSet/dsFrmPayAccount.cs

using System;
using System.CodeDom.Compiler;
using System.Collections;
using System.ComponentModel;
using System.ComponentModel.Design;
using System.Data;
using System.Diagnostics;
using System.IO;
using System.Runtime.Serialization;
using System.Xml;
using System.Xml.Schema;
using System.Xml.Serialization;

namespace SunRoxm.BizPeri.ReportDataSet.ReportDataSet
{
	[Serializable]
	[GeneratedCode("System.Data.Design.TypedDataSetGenerator", "2.0.0.0")]
	[HelpKeyword("vs.data.DataSet")]
	[DesignerCategory("code")]
	[ToolboxItem(true)]
	[XmlSchemaProvider("GetTypedDataSetSchema")]
	[XmlRoot("dsFrmPayAccount")]
	public class dsFrmPayAccount : DataSet
	{
		public delegate void PayAccountRowChangeEventHandler(object sender, PayAccountRowChangeEvent e);

		public delegate void PayAccountDataRowChangeEventHandler(object sender, PayAccountDataRowChangeEvent e);

		[Serializable]
		[GeneratedCode("System.Data.Design.TypedDataSetGenerator", "2.0.0.0")]
		[XmlSchemaProvider("GetTypedTableSchema")]
		public class PayAccountDataTable : DataTable, IEnumerable
		{
			private DataColumn columnNo_AttendanceResult;

			private DataColumn columnName_Department;

			private DataColumn columnBegin_AttendanceResult;

			private DataColumn columnEnd_AttendanceResult;

			private DataColumn columnFactDays_AttendanceResult;

			private DataColumn columnPayDays_PayAccount;

			private DataColumn columnName_Creator;

			private DataColumn columnCreateDate_PayAccount;

			private DataColumn columnName_Assessor;

			private DataColumn columnAssessDate_PayAccount;

			private DataColumn columnLastModUserName;

			private DataColumn columnLastModDate_PayAccount;

			[DebuggerNonUserCode]
			public DataColumn No_AttendanceResultColumn => columnNo_AttendanceResult;

			[DebuggerNonUserCode]
			public DataColumn Name_DepartmentColumn => columnName_Department;

			[DebuggerNonUserCode]
			public DataColumn Begin_AttendanceResultColumn => columnBegin_AttendanceResult;

			[DebuggerNonUserCode]
			public DataColumn End_AttendanceResultColumn => columnEnd_AttendanceResult;

			[DebuggerNonUserCode]
			public DataColumn FactDays_AttendanceResultColumn => columnFactDays_AttendanceResult;

			[DebuggerNonUserCode]
			public DataColumn PayDays_PayAccountColumn => columnPayDays_PayAccount;

			[DebuggerNonUserCode]
			public DataColumn Name_CreatorColumn => columnName_Creator;

			[DebuggerNonUserCode]
			public DataColumn CreateDate_PayAccountColumn => columnCreateDate_PayAccount;

			[DebuggerNonUserCode]
			public DataColumn Name_AssessorColumn => columnName_Assessor;

			[DebuggerNonUserCode]
			public DataColumn AssessDate_PayAccountColumn => columnAssessDate_PayAccount;

			[DebuggerNonUserCode]
			public DataColumn LastModUserNameColumn => columnLastModUserName;

			[DebuggerNonUserCode]
			public DataColumn LastModDate_PayAccountColumn => columnLastModDate_PayAccount;

			[DebuggerNonUserCode]
			[Browsable(false)]
			public int Count => base.Rows.Count;

			[DebuggerNonUserCode]
			public PayAccountRow this[int index] => (PayAccountRow)base.Rows[index];

			public event PayAccountRowChangeEventHandler PayAccountRowChanging;

			public event PayAccountRowChangeEventHandler PayAccountRowChanged;

			public event PayAccountRowChangeEventHandler PayAccountRowDeleting;

			public event PayAccountRowChangeEventHandler PayAccountRowDeleted;

			[DebuggerNonUserCode]
			public PayAccountDataTable()
			{
				base.TableName = "PayAccount";
				BeginInit();
				InitClass();
				EndInit();
			}

			[DebuggerNonUserCode]
			internal PayAccountDataTable(DataTable table)
			{
				base.TableName = table.TableName;
				if (table.CaseSensitive != table.DataSet.CaseSensitive)
				{
					base.CaseSensitive = table.CaseSensitive;
				}
				if (table.Locale.ToString() != table.DataSet.Locale.ToString())
				{
					base.Locale = table.Locale;
				}
				if (table.Namespace != table.DataSet.Namespace)
				{
					base.Namespace = table.Namespace;
				}
				base.Prefix = table.Prefix;
				base.MinimumCapacity = table.MinimumCapacity;
			}

			[DebuggerNonUserCode]
			protected PayAccountDataTable(SerializationInfo info, StreamingContext context)
				: base(info, context)
			{
				InitVars();
			}

			[DebuggerNonUserCode]
			public void AddPayAccountRow(PayAccountRow row)
			{
				base.Rows.Add(row);
			}

			[DebuggerNonUserCode]
			public PayAccountRow AddPayAccountRow(string No_AttendanceResult, string Name_Department, DateTime Begin_AttendanceResult, DateTime End_AttendanceResult, decimal FactDays_AttendanceResult, decimal PayDays_PayAccount, string Name_Creator, DateTime CreateDate_PayAccount, string Name_Assessor, DateTime AssessDate_PayAccount, string LastModUserName, DateTime LastModDate_PayAccount)
			{
				PayAccountRow payAccountRow = (PayAccountRow)NewRow();
				object[] array2 = payAccountRow.ItemArray = new object[12]
				{
					No_AttendanceResult,
					Name_Department,
					Begin_AttendanceResult,
					End_AttendanceResult,
					FactDays_AttendanceResult,
					PayDays_PayAccount,
					Name_Creator,
					CreateDate_PayAccount,
					Name_Assessor,
					AssessDate_PayAccount,
					LastModUserName,
					LastModDate_PayAccount
				};
				base.Rows.Add(payAccountRow);
				return payAccountRow;
			}

			[DebuggerNonUserCode]
			public virtual IEnumerator GetEnumerator()
			{
				return base.Rows.GetEnumerator();
			}

			[DebuggerNonUserCode]
			public override DataTable Clone()
			{
				PayAccountDataTable payAccountDataTable = (PayAccountDataTable)base.Clone();
				payAccountDataTable.InitVars();
				return payAccountDataTable;
			}

			[DebuggerNonUserCode]
			protected override DataTable CreateInstance()
			{
				return new PayAccountDataTable();
			}

			[DebuggerNonUserCode]
			internal void InitVars()
			{
				columnNo_AttendanceResult = base.Columns["No_AttendanceResult"];
				columnName_Department = base.Columns["Name_Department"];
				columnBegin_AttendanceResult = base.Columns["Begin_AttendanceResult"];
				columnEnd_AttendanceResult = base.Columns["End_AttendanceResult"];
				columnFactDays_AttendanceResult = base.Columns["FactDays_AttendanceResult"];
				columnPayDays_PayAccount = base.Columns["PayDays_PayAccount"];
				columnName_Creator = base.Columns["Name_Creator"];
				columnCreateDate_PayAccount = base.Columns["CreateDate_PayAccount"];
				columnName_Assessor = base.Columns["Name_Assessor"];
				columnAssessDate_PayAccount = base.Columns["AssessDate_PayAccount"];
				columnLastModUserName = base.Columns["LastModUserName"];
				columnLastModDate_PayAccount = base.Columns["LastModDate_PayAccount"];
			}

			[DebuggerNonUserCode]
			private void InitClass()
			{
				columnNo_AttendanceResult = new DataColumn("No_AttendanceResult", typeof(string), null, MappingType.Element);
				base.Columns.Add(columnNo_AttendanceResult);
				columnName_Department = new DataColumn("Name_Department", typeof(string), null, MappingType.Element);
				base.Columns.Add(columnName_Department);
				columnBegin_AttendanceResult = new DataColumn("Begin_AttendanceResult", typeof(DateTime), null, MappingType.Element);
				base.Columns.Add(columnBegin_AttendanceResult);
				columnEnd_AttendanceResult = new DataColumn("End_AttendanceResult", typeof(DateTime), null, MappingType.Element);
				base.Columns.Add(columnEnd_AttendanceResult);
				columnFactDays_AttendanceResult = new DataColumn("FactDays_AttendanceResult", typeof(decimal), null, MappingType.Element);
				base.Columns.Add(columnFactDays_AttendanceResult);
				columnPayDays_PayAccount = new DataColumn("PayDays_PayAccount", typeof(decimal), null, MappingType.Element);
				base.Columns.Add(columnPayDays_PayAccount);
				columnName_Creator = new DataColumn("Name_Creator", typeof(string), null, MappingType.Element);
				base.Columns.Add(columnName_Creator);
				columnCreateDate_PayAccount = new DataColumn("CreateDate_PayAccount", typeof(DateTime), null, MappingType.Element);
				base.Columns.Add(columnCreateDate_PayAccount);
				columnName_Assessor = new DataColumn("Name_Assessor", typeof(string), null, MappingType.Element);
				base.Columns.Add(columnName_Assessor);
				columnAssessDate_PayAccount = new DataColumn("AssessDate_PayAccount", typeof(DateTime), null, MappingType.Element);
				base.Columns.Add(columnAssessDate_PayAccount);
				columnLastModUserName = new DataColumn("LastModUserName", typeof(string), null, MappingType.Element);
				base.Columns.Add(columnLastModUserName);
				columnLastModDate_PayAccount = new DataColumn("LastModDate_PayAccount", typeof(DateTime), null, MappingType.Element);
				base.Columns.Add(columnLastModDate_PayAccount);
			}

			[DebuggerNonUserCode]
			public PayAccountRow NewPayAccountRow()
			{
				return (PayAccountRow)NewRow();
			}

			[DebuggerNonUserCode]
			protected override DataRow NewRowFromBuilder(DataRowBuilder builder)
			{
				return new PayAccountRow(builder);
			}

			[DebuggerNonUserCode]
			protected override Type GetRowType()
			{
				return typeof(PayAccountRow);
			}

			[DebuggerNonUserCode]
			protected override void OnRowChanged(DataRowChangeEventArgs e)
			{
				base.OnRowChanged(e);
				if (this.PayAccountRowChanged != null)
				{
					this.PayAccountRowChanged(this, new PayAccountRowChangeEvent((PayAccountRow)e.Row, e.Action));
				}
			}

			[DebuggerNonUserCode]
			protected override void OnRowChanging(DataRowChangeEventArgs e)
			{
				base.OnRowChanging(e);
				if (this.PayAccountRowChanging != null)
				{
					this.PayAccountRowChanging(this, new PayAccountRowChangeEvent((PayAccountRow)e.Row, e.Action));
				}
			}

			[DebuggerNonUserCode]
			protected override void OnRowDeleted(DataRowChangeEventArgs e)
			{
				base.OnRowDeleted(e);
				if (this.PayAccountRowDeleted != null)
				{
					this.PayAccountRowDeleted(this, new PayAccountRowChangeEvent((PayAccountRow)e.Row, e.Action));
				}
			}

			[DebuggerNonUserCode]
			protected override void OnRowDeleting(DataRowChangeEventArgs e)
			{
				base.OnRowDeleting(e);
				if (this.PayAccountRowDeleting != null)
				{
					this.PayAccountRowDeleting(this, new PayAccountRowChangeEvent((PayAccountRow)e.Row, e.Action));
				}
			}

			[DebuggerNonUserCode]
			public void RemovePayAccountRow(PayAccountRow row)
			{
				base.Rows.Remove(row);
			}

			[DebuggerNonUserCode]
			public static XmlSchemaComplexType GetTypedTableSchema(XmlSchemaSet xs)
			{
				XmlSchemaComplexType xmlSchemaComplexType = new XmlSchemaComplexType();
				XmlSchemaSequence xmlSchemaSequence = new XmlSchemaSequence();
				dsFrmPayAccount dsFrmPayAccount = new dsFrmPayAccount();
				XmlSchemaAny xmlSchemaAny = new XmlSchemaAny();
				xmlSchemaAny.Namespace = "http://www.w3.org/2001/XMLSchema";
				xmlSchemaAny.MinOccurs = 0m;
				xmlSchemaAny.MaxOccurs = decimal.MaxValue;
				xmlSchemaAny.ProcessContents = XmlSchemaContentProcessing.Lax;
				xmlSchemaSequence.Items.Add(xmlSchemaAny);
				XmlSchemaAny xmlSchemaAny2 = new XmlSchemaAny();
				xmlSchemaAny2.Namespace = "urn:schemas-microsoft-com:xml-diffgram-v1";
				xmlSchemaAny2.MinOccurs = 1m;
				xmlSchemaAny2.ProcessContents = XmlSchemaContentProcessing.Lax;
				xmlSchemaSequence.Items.Add(xmlSchemaAny2);
				XmlSchemaAttribute xmlSchemaAttribute = new XmlSchemaAttribute();
				xmlSchemaAttribute.Name = "namespace";
				xmlSchemaAttribute.FixedValue = dsFrmPayAccount.Namespace;
				xmlSchemaComplexType.Attributes.Add(xmlSchemaAttribute);
				XmlSchemaAttribute xmlSchemaAttribute2 = new XmlSchemaAttribute();
				xmlSchemaAttribute2.Name = "tableTypeName";
				xmlSchemaAttribute2.FixedValue = "PayAccountDataTable";
				xmlSchemaComplexType.Attributes.Add(xmlSchemaAttribute2);
				xmlSchemaComplexType.Particle = xmlSchemaSequence;
				XmlSchema schemaSerializable = dsFrmPayAccount.GetSchemaSerializable();
				if (xs.Contains(schemaSerializable.TargetNamespace))
				{
					MemoryStream memoryStream = new MemoryStream();
					MemoryStream memoryStream2 = new MemoryStream();
					try
					{
						XmlSchema xmlSchema = null;
						schemaSerializable.Write(memoryStream);
						IEnumerator enumerator = xs.Schemas(schemaSerializable.TargetNamespace).GetEnumerator();
						while (enumerator.MoveNext())
						{
							xmlSchema = (XmlSchema)enumerator.Current;
							memoryStream2.SetLength(0L);
							xmlSchema.Write(memoryStream2);
							if (memoryStream.Length == memoryStream2.Length)
							{
								memoryStream.Position = 0L;
								memoryStream2.Position = 0L;
								while (memoryStream.Position != memoryStream.Length && memoryStream.ReadByte() == memoryStream2.ReadByte())
								{
								}
								if (memoryStream.Position == memoryStream.Length)
								{
									return xmlSchemaComplexType;
								}
							}
						}
					}
					finally
					{
						memoryStream?.Close();
						memoryStream2?.Close();
					}
				}
				xs.Add(schemaSerializable);
				return xmlSchemaComplexType;
			}
		}

		[Serializable]
		[GeneratedCode("System.Data.Design.TypedDataSetGenerator", "2.0.0.0")]
		[XmlSchemaProvider("GetTypedTableSchema")]
		public class PayAccountDataDataTable : DataTable, IEnumerable
		{
			private DataColumn columnNo_Employee;

			private DataColumn columnName_Employee;

			private DataColumn columnBasicPay_PayAccountData;

			private DataColumn columnOvertimePay_PayAccountData;

			private DataColumn columnAttendanceBounty_PayAccountData;

			private DataColumn columnLater_PayAccountData;

			private DataColumn columnLeaveEarly_PayAccountData;

			private DataColumn columnAbsent_PayAccountData;

			private DataColumn columnSick_PayAccountData;

			private DataColumn columnEvent_PayAccountData;

			private DataColumn columnProvide_PayAccountData;

			private DataColumn columnIdleness_PayAccountData;

			private DataColumn columnMedical_PayAccountData;

			private DataColumn columnAccumulationFund_PayAccountData;

			private DataColumn columnBonus_PayAccountData;

			private DataColumn columnDetain_PayAccountData;

			private DataColumn columnTotal_PayAccountData;

			private DataColumn columnTax_PayAccountData;

			private DataColumn columnFactPay_PayAccountData;

			private DataColumn columnComment_PayAccountData;

			[DebuggerNonUserCode]
			public DataColumn No_EmployeeColumn => columnNo_Employee;

			[DebuggerNonUserCode]
			public DataColumn Name_EmployeeColumn => columnName_Employee;

			[DebuggerNonUserCode]
			public DataColumn BasicPay_PayAccountDataColumn => columnBasicPay_PayAccountData;

			[DebuggerNonUserCode]
			public DataColumn OvertimePay_PayAccountDataColumn => columnOvertimePay_PayAccountData;

			[DebuggerNonUserCode]
			public DataColumn AttendanceBounty_PayAccountDataColumn => columnAttendanceBounty_PayAccountData;

			[DebuggerNonUserCode]
			public DataColumn Later_PayAccountDataColumn => columnLater_PayAccountData;

			[DebuggerNonUserCode]
			public DataColumn LeaveEarly_PayAccountDataColumn => columnLeaveEarly_PayAccountData;

			[DebuggerNonUserCode]
			public DataColumn Absent_PayAccountDataColumn => columnAbsent_PayAccountData;

			[DebuggerNonUserCode]
			public DataColumn Sick_PayAccountDataColumn => columnSick_PayAccountData;

			[DebuggerNonUserCode]
			public DataColumn Event_PayAccountDataColumn => columnEvent_PayAccountData;

			[DebuggerNonUserCode]
			public DataColumn Provide_PayAccountDataColumn => columnProvide_PayAccountData;

			[DebuggerNonUserCode]
			public DataColumn Idleness_PayAccountDataColumn => columnIdleness_PayAccountData;

			[DebuggerNonUserCode]
			public DataColumn Medical_PayAccountDataColumn => columnMedical_PayAccountData;

			[DebuggerNonUserCode]
			public DataColumn AccumulationFund_PayAccountDataColumn => columnAccumulationFund_PayAccountData;

			[DebuggerNonUserCode]
			public DataColumn Bonus_PayAccountDataColumn => columnBonus_PayAccountData;

			[DebuggerNonUserCode]
			public DataColumn Detain_PayAccountDataColumn => columnDetain_PayAccountData;

			[DebuggerNonUserCode]
			public DataColumn Total_PayAccountDataColumn => columnTotal_PayAccountData;

			[DebuggerNonUserCode]
			public DataColumn Tax_PayAccountDataColumn => columnTax_PayAccountData;

			[DebuggerNonUserCode]
			public DataColumn FactPay_PayAccountDataColumn => columnFactPay_PayAccountData;

			[DebuggerNonUserCode]
			public DataColumn Comment_PayAccountDataColumn => columnComment_PayAccountData;

			[Browsable(false)]
			[DebuggerNonUserCode]
			public int Count => base.Rows.Count;

			[DebuggerNonUserCode]
			public PayAccountDataRow this[int index] => (PayAccountDataRow)base.Rows[index];

			public event PayAccountDataRowChangeEventHandler PayAccountDataRowChanging;

			public event PayAccountDataRowChangeEventHandler PayAccountDataRowChanged;

			public event PayAccountDataRowChangeEventHandler PayAccountDataRowDeleting;

			public event PayAccountDataRowChangeEventHandler PayAccountDataRowDeleted;

			[DebuggerNonUserCode]
			public PayAccountDataDataTable()
			{
				base.TableName = "PayAccountData";
				BeginInit();
				InitClass();
				EndInit();
			}

			[DebuggerNonUserCode]
			internal PayAccountDataDataTable(DataTable table)
			{
				base.TableName = table.TableName;
				if (table.CaseSensitive != table.DataSet.CaseSensitive)
				{
					base.CaseSensitive = table.CaseSensitive;
				}
				if (table.Locale.ToString() != table.DataSet.Locale.ToString())
				{
					base.Locale = table.Locale;
				}
				if (table.Namespace != table.DataSet.Namespace)
				{
					base.Namespace = table.Namespace;
				}
				base.Prefix = table.Prefix;
				base.MinimumCapacity = table.MinimumCapacity;
			}

			[DebuggerNonUserCode]
			protected PayAccountDataDataTable(SerializationInfo info, StreamingContext context)
				: base(info, context)
			{
				InitVars();
			}

			[DebuggerNonUserCode]
			public void AddPayAccountDataRow(PayAccountDataRow row)
			{
				base.Rows.Add(row);
			}

			[DebuggerNonUserCode]
			public PayAccountDataRow AddPayAccountDataRow(string No_Employee, string Name_Employee, decimal BasicPay_PayAccountData, decimal OvertimePay_PayAccountData, decimal AttendanceBounty_PayAccountData, decimal Later_PayAccountData, decimal LeaveEarly_PayAccountData, decimal Absent_PayAccountData, decimal Sick_PayAccountData, decimal Event_PayAccountData, decimal Provide_PayAccountData, decimal Idleness_PayAccountData, decimal Medical_PayAccountData, decimal AccumulationFund_PayAccountData, decimal Bonus_PayAccountData, decimal Detain_PayAccountData, decimal Total_PayAccountData, decimal Tax_PayAccountData, decimal FactPay_PayAccountData, string Comment_PayAccountData)
			{
				PayAccountDataRow payAccountDataRow = (PayAccountDataRow)NewRow();
				object[] array2 = payAccountDataRow.ItemArray = new object[20]
				{
					No_Employee,
					Name_Employee,
					BasicPay_PayAccountData,
					OvertimePay_PayAccountData,
					AttendanceBounty_PayAccountData,
					Later_PayAccountData,
					LeaveEarly_PayAccountData,
					Absent_PayAccountData,
					Sick_PayAccountData,
					Event_PayAccountData,
					Provide_PayAccountData,
					Idleness_PayAccountData,
					Medical_PayAccountData,
					AccumulationFund_PayAccountData,
					Bonus_PayAccountData,
					Detain_PayAccountData,
					Total_PayAccountData,
					Tax_PayAccountData,
					FactPay_PayAccountData,
					Comment_PayAccountData
				};
				base.Rows.Add(payAccountDataRow);
				return payAccountDataRow;
			}

			[DebuggerNonUserCode]
			public virtual IEnumerator GetEnumerator()
			{
				return base.Rows.GetEnumerator();
			}

			[DebuggerNonUserCode]
			public override DataTable Clone()
			{
				PayAccountDataDataTable payAccountDataDataTable = (PayAccountDataDataTable)base.Clone();
				payAccountDataDataTable.InitVars();
				return payAccountDataDataTable;
			}

			[DebuggerNonUserCode]
			protected override DataTable CreateInstance()
			{
				return new PayAccountDataDataTable();
			}

			[DebuggerNonUserCode]
			internal void InitVars()
			{
				columnNo_Employee = base.Columns["No_Employee"];
				columnName_Employee = base.Columns["Name_Employee"];
				columnBasicPay_PayAccountData = base.Columns["BasicPay_PayAccountData"];
				columnOvertimePay_PayAccountData = base.Columns["OvertimePay_PayAccountData"];
				columnAttendanceBounty_PayAccountData = base.Columns["AttendanceBounty_PayAccountData"];
				columnLater_PayAccountData = base.Columns["Later_PayAccountData"];
				columnLeaveEarly_PayAccountData = base.Columns["LeaveEarly_PayAccountData"];
				columnAbsent_PayAccountData = base.Columns["Absent_PayAccountData"];
				columnSick_PayAccountData = base.Columns["Sick_PayAccountData"];
				columnEvent_PayAccountData = base.Columns["Event_PayAccountData"];
				columnProvide_PayAccountData = base.Columns["Provide_PayAccountData"];
				columnIdleness_PayAccountData = base.Columns["Idleness_PayAccountData"];
				columnMedical_PayAccountData = base.Columns["Medical_PayAccountData"];
				columnAccumulationFund_PayAccountData = base.Columns["AccumulationFund_PayAccountData"];
				columnBonus_PayAccountData = base.Columns["Bonus_PayAccountData"];
				columnDetain_PayAccountData = base.Columns["Detain_PayAccountData"];
				columnTotal_PayAccountData = base.Columns["Total_PayAccountData"];
				columnTax_PayAccountData = base.Columns["Tax_PayAccountData"];
				columnFactPay_PayAccountData = base.Columns["FactPay_PayAccountData"];
				columnComment_PayAccountData = base.Columns["Comment_PayAccountData"];
			}

			[DebuggerNonUserCode]
			private void InitClass()
			{
				columnNo_Employee = new DataColumn("No_Employee", typeof(string), null, MappingType.Element);
				base.Columns.Add(columnNo_Employee);
				columnName_Employee = new DataColumn("Name_Employee", typeof(string), null, MappingType.Element);
				base.Columns.Add(columnName_Employee);
				columnBasicPay_PayAccountData = new DataColumn("BasicPay_PayAccountData", typeof(decimal), null, MappingType.Element);
				base.Columns.Add(columnBasicPay_PayAccountData);
				columnOvertimePay_PayAccountData = new DataColumn("OvertimePay_PayAccountData", typeof(decimal), null, MappingType.Element);
				base.Columns.Add(columnOvertimePay_PayAccountData);
				columnAttendanceBounty_PayAccountData = new DataColumn("AttendanceBounty_PayAccountData", typeof(decimal), null, MappingType.Element);
				base.Columns.Add(columnAttendanceBounty_PayAccountData);
				columnLater_PayAccountData = new DataColumn("Later_PayAccountData", typeof(decimal), null, MappingType.Element);
				base.Columns.Add(columnLater_PayAccountData);
				columnLeaveEarly_PayAccountData = new DataColumn("LeaveEarly_PayAccountData", typeof(decimal), null, MappingType.Element);
				base.Columns.Add(columnLeaveEarly_PayAccountData);
				columnAbsent_PayAccountData = new DataColumn("Absent_PayAccountData", typeof(decimal), null, MappingType.Element);
				base.Columns.Add(columnAbsent_PayAccountData);
				columnSick_PayAccountData = new DataColumn("Sick_PayAccountData", typeof(decimal), null, MappingType.Element);
				base.Columns.Add(columnSick_PayAccountData);
				columnEvent_PayAccountData = new DataColumn("Event_PayAccountData", typeof(decimal), null, MappingType.Element);
				base.Columns.Add(columnEvent_PayAccountData);
				columnProvide_PayAccountData = new DataColumn("Provide_PayAccountData", typeof(decimal), null, MappingType.Element);
				base.Columns.Add(columnProvide_PayAccountData);
				columnIdleness_PayAccountData = new DataColumn("Idleness_PayAccountData", typeof(decimal), null, MappingType.Element);
				base.Columns.Add(columnIdleness_PayAccountData);
				columnMedical_PayAccountData = new DataColumn("Medical_PayAccountData", typeof(decimal), null, MappingType.Element);
				base.Columns.Add(columnMedical_PayAccountData);
				columnAccumulationFund_PayAccountData = new DataColumn("AccumulationFund_PayAccountData", typeof(decimal), null, MappingType.Element);
				base.Columns.Add(columnAccumulationFund_PayAccountData);
				columnBonus_PayAccountData = new DataColumn("Bonus_PayAccountData", typeof(decimal), null, MappingType.Element);
				base.Columns.Add(columnBonus_PayAccountData);
				columnDetain_PayAccountData = new DataColumn("Detain_PayAccountData", typeof(decimal), null, MappingType.Element);
				base.Columns.Add(columnDetain_PayAccountData);
				columnTotal_PayAccountData = new DataColumn("Total_PayAccountData", typeof(decimal), null, MappingType.Element);
				base.Columns.Add(columnTotal_PayAccountData);
				columnTax_PayAccountData = new DataColumn("Tax_PayAccountData", typeof(decimal), null, MappingType.Element);
				base.Columns.Add(columnTax_PayAccountData);
				columnFactPay_PayAccountData = new DataColumn("FactPay_PayAccountData", typeof(decimal), null, MappingType.Element);
				base.Columns.Add(columnFactPay_PayAccountData);
				columnComment_PayAccountData = new DataColumn("Comment_PayAccountData", typeof(string), null, MappingType.Element);
				base.Columns.Add(columnComment_PayAccountData);
			}

			[DebuggerNonUserCode]
			public PayAccountDataRow NewPayAccountDataRow()
			{
				return (PayAccountDataRow)NewRow();
			}

			[DebuggerNonUserCode]
			protected override DataRow NewRowFromBuilder(DataRowBuilder builder)
			{
				return new PayAccountDataRow(builder);
			}

			[DebuggerNonUserCode]
			protected override Type GetRowType()
			{
				return typeof(PayAccountDataRow);
			}

			[DebuggerNonUserCode]
			protected override void OnRowChanged(DataRowChangeEventArgs e)
			{
				base.OnRowChanged(e);
				if (this.PayAccountDataRowChanged != null)
				{
					this.PayAccountDataRowChanged(this, new PayAccountDataRowChangeEvent((PayAccountDataRow)e.Row, e.Action));
				}
			}

			[DebuggerNonUserCode]
			protected override void OnRowChanging(DataRowChangeEventArgs e)
			{
				base.OnRowChanging(e);
				if (this.PayAccountDataRowChanging != null)
				{
					this.PayAccountDataRowChanging(this, new PayAccountDataRowChangeEvent((PayAccountDataRow)e.Row, e.Action));
				}
			}

			[DebuggerNonUserCode]
			protected override void OnRowDeleted(DataRowChangeEventArgs e)
			{
				base.OnRowDeleted(e);
				if (this.PayAccountDataRowDeleted != null)
				{
					this.PayAccountDataRowDeleted(this, new PayAccountDataRowChangeEvent((PayAccountDataRow)e.Row, e.Action));
				}
			}

			[DebuggerNonUserCode]
			protected override void OnRowDeleting(DataRowChangeEventArgs e)
			{
				base.OnRowDeleting(e);
				if (this.PayAccountDataRowDeleting != null)
				{
					this.PayAccountDataRowDeleting(this, new PayAccountDataRowChangeEvent((PayAccountDataRow)e.Row, e.Action));
				}
			}

			[DebuggerNonUserCode]
			public void RemovePayAccountDataRow(PayAccountDataRow row)
			{
				base.Rows.Remove(row);
			}

			[DebuggerNonUserCode]
			public static XmlSchemaComplexType GetTypedTableSchema(XmlSchemaSet xs)
			{
				XmlSchemaComplexType xmlSchemaComplexType = new XmlSchemaComplexType();
				XmlSchemaSequence xmlSchemaSequence = new XmlSchemaSequence();
				dsFrmPayAccount dsFrmPayAccount = new dsFrmPayAccount();
				XmlSchemaAny xmlSchemaAny = new XmlSchemaAny();
				xmlSchemaAny.Namespace = "http://www.w3.org/2001/XMLSchema";
				xmlSchemaAny.MinOccurs = 0m;
				xmlSchemaAny.MaxOccurs = decimal.MaxValue;
				xmlSchemaAny.ProcessContents = XmlSchemaContentProcessing.Lax;
				xmlSchemaSequence.Items.Add(xmlSchemaAny);
				XmlSchemaAny xmlSchemaAny2 = new XmlSchemaAny();
				xmlSchemaAny2.Namespace = "urn:schemas-microsoft-com:xml-diffgram-v1";
				xmlSchemaAny2.MinOccurs = 1m;
				xmlSchemaAny2.ProcessContents = XmlSchemaContentProcessing.Lax;
				xmlSchemaSequence.Items.Add(xmlSchemaAny2);
				XmlSchemaAttribute xmlSchemaAttribute = new XmlSchemaAttribute();
				xmlSchemaAttribute.Name = "namespace";
				xmlSchemaAttribute.FixedValue = dsFrmPayAccount.Namespace;
				xmlSchemaComplexType.Attributes.Add(xmlSchemaAttribute);
				XmlSchemaAttribute xmlSchemaAttribute2 = new XmlSchemaAttribute();
				xmlSchemaAttribute2.Name = "tableTypeName";
				xmlSchemaAttribute2.FixedValue = "PayAccountDataDataTable";
				xmlSchemaComplexType.Attributes.Add(xmlSchemaAttribute2);
				xmlSchemaComplexType.Particle = xmlSchemaSequence;
				XmlSchema schemaSerializable = dsFrmPayAccount.GetSchemaSerializable();
				if (xs.Contains(schemaSerializable.TargetNamespace))
				{
					MemoryStream memoryStream = new MemoryStream();
					MemoryStream memoryStream2 = new MemoryStream();
					try
					{
						XmlSchema xmlSchema = null;
						schemaSerializable.Write(memoryStream);
						IEnumerator enumerator = xs.Schemas(schemaSerializable.TargetNamespace).GetEnumerator();
						while (enumerator.MoveNext())
						{
							xmlSchema = (XmlSchema)enumerator.Current;
							memoryStream2.SetLength(0L);
							xmlSchema.Write(memoryStream2);
							if (memoryStream.Length == memoryStream2.Length)
							{
								memoryStream.Position = 0L;
								memoryStream2.Position = 0L;
								while (memoryStream.Position != memoryStream.Length && memoryStream.ReadByte() == memoryStream2.ReadByte())
								{
								}
								if (memoryStream.Position == memoryStream.Length)
								{
									return xmlSchemaComplexType;
								}
							}
						}
					}
					finally
					{
						memoryStream?.Close();
						memoryStream2?.Close();
					}
				}
				xs.Add(schemaSerializable);
				return xmlSchemaComplexType;
			}
		}

		[GeneratedCode("System.Data.Design.TypedDataSetGenerator", "2.0.0.0")]
		public class PayAccountRow : DataRow
		{
			private PayAccountDataTable tablePayAccount;

			[DebuggerNonUserCode]
			public string No_AttendanceResult
			{
				get
				{
					try
					{
						return (string)base[tablePayAccount.No_AttendanceResultColumn];
					}
					catch (InvalidCastException innerException)
					{
						throw new StrongTypingException("The value for column 'No_AttendanceResult' in table 'PayAccount' is DBNull.", innerException);
					}
				}
				set
				{
					base[tablePayAccount.No_AttendanceResultColumn] = value;
				}
			}

			[DebuggerNonUserCode]
			public string Name_Department
			{
				get
				{
					try
					{
						return (string)base[tablePayAccount.Name_DepartmentColumn];
					}
					catch (InvalidCastException innerException)
					{
						throw new StrongTypingException("The value for column 'Name_Department' in table 'PayAccount' is DBNull.", innerException);
					}
				}
				set
				{
					base[tablePayAccount.Name_DepartmentColumn] = value;
				}
			}

			[DebuggerNonUserCode]
			public DateTime Begin_AttendanceResult
			{
				get
				{
					try
					{
						return (DateTime)base[tablePayAccount.Begin_AttendanceResultColumn];
					}
					catch (InvalidCastException innerException)
					{
						throw new StrongTypingException("The value for column 'Begin_AttendanceResult' in table 'PayAccount' is DBNull.", innerException);
					}
				}
				set
				{
					base[tablePayAccount.Begin_AttendanceResultColumn] = value;
				}
			}

			[DebuggerNonUserCode]
			public DateTime End_AttendanceResult
			{
				get
				{
					try
					{
						return (DateTime)base[tablePayAccount.End_AttendanceResultColumn];
					}
					catch (InvalidCastException innerException)
					{
						throw new StrongTypingException("The value for column 'End_AttendanceResult' in table 'PayAccount' is DBNull.", innerException);
					}
				}
				set
				{
					base[tablePayAccount.End_AttendanceResultColumn] = value;
				}
			}

			[DebuggerNonUserCode]
			public decimal FactDays_AttendanceResult
			{
				get
				{
					try
					{
						return (decimal)base[tablePayAccount.FactDays_AttendanceResultColumn];
					}
					catch (InvalidCastException innerException)
					{
						throw new StrongTypingException("The value for column 'FactDays_AttendanceResult' in table 'PayAccount' is DBNull.", innerException);
					}
				}
				set
				{
					base[tablePayAccount.FactDays_AttendanceResultColumn] = value;
				}
			}

			[DebuggerNonUserCode]
			public decimal PayDays_PayAccount
			{
				get
				{
					try
					{
						return (decimal)base[tablePayAccount.PayDays_PayAccountColumn];
					}
					catch (InvalidCastException innerException)
					{
						throw new StrongTypingException("The value for column 'PayDays_PayAccount' in table 'PayAccount' is DBNull.", innerException);
					}
				}
				set
				{
					base[tablePayAccount.PayDays_PayAccountColumn] = value;
				}
			}

			[DebuggerNonUserCode]
			public string Name_Creator
			{
				get
				{
					try
					{
						return (string)base[tablePayAccount.Name_CreatorColumn];
					}
					catch (InvalidCastException innerException)
					{
						throw new StrongTypingException("The value for column 'Name_Creator' in table 'PayAccount' is DBNull.", innerException);
					}
				}
				set
				{
					base[tablePayAccount.Name_CreatorColumn] = value;
				}
			}

			[DebuggerNonUserCode]
			public DateTime CreateDate_PayAccount
			{
				get
				{
					try
					{
						return (DateTime)base[tablePayAccount.CreateDate_PayAccountColumn];
					}
					catch (InvalidCastException innerException)
					{
						throw new StrongTypingException("The value for column 'CreateDate_PayAccount' in table 'PayAccount' is DBNull.", innerException);
					}
				}
				set
				{
					base[tablePayAccount.CreateDate_PayAccountColumn] = value;
				}
			}

			[DebuggerNonUserCode]
			public string Name_Assessor
			{
				get
				{
					try
					{
						return (string)base[tablePayAccount.Name_AssessorColumn];
					}
					catch (InvalidCastException innerException)
					{
						throw new StrongTypingException("The value for column 'Name_Assessor' in table 'PayAccount' is DBNull.", innerException);
					}
				}
				set
				{
					base[tablePayAccount.Name_AssessorColumn] = value;
				}
			}

			[DebuggerNonUserCode]
			public DateTime AssessDate_PayAccount
			{
				get
				{
					try
					{
						return (DateTime)base[tablePayAccount.AssessDate_PayAccountColumn];
					}
					catch (InvalidCastException innerException)
					{
						throw new StrongTypingException("The value for column 'AssessDate_PayAccount' in table 'PayAccount' is DBNull.", innerException);
					}
				}
				set
				{
					base[tablePayAccount.AssessDate_PayAccountColumn] = value;
				}
			}

			[DebuggerNonUserCode]
			public string LastModUserName
			{
				get
				{
					try
					{
						return (string)base[tablePayAccount.LastModUserNameColumn];
					}
					catch (InvalidCastException innerException)
					{
						throw new StrongTypingException("The value for column 'LastModUserName' in table 'PayAccount' is DBNull.", innerException);
					}
				}
				set
				{
					base[tablePayAccount.LastModUserNameColumn] = value;
				}
			}

			[DebuggerNonUserCode]
			public DateTime LastModDate_PayAccount
			{
				get
				{
					try
					{
						return (DateTime)base[tablePayAccount.LastModDate_PayAccountColumn];
					}
					catch (InvalidCastException innerException)
					{
						throw new StrongTypingException("The value for column 'LastModDate_PayAccount' in table 'PayAccount' is DBNull.", innerException);
					}
				}
				set
				{
					base[tablePayAccount.LastModDate_PayAccountColumn] = value;
				}
			}

			[DebuggerNonUserCode]
			internal PayAccountRow(DataRowBuilder rb)
				: base(rb)
			{
				tablePayAccount = (PayAccountDataTable)base.Table;
			}

			[DebuggerNonUserCode]
			public bool IsNo_AttendanceResultNull()
			{
				return IsNull(tablePayAccount.No_AttendanceResultColumn);
			}

			[DebuggerNonUserCode]
			public void SetNo_AttendanceResultNull()
			{
				base[tablePayAccount.No_AttendanceResultColumn] = Convert.DBNull;
			}

			[DebuggerNonUserCode]
			public bool IsName_DepartmentNull()
			{
				return IsNull(tablePayAccount.Name_DepartmentColumn);
			}

			[DebuggerNonUserCode]
			public void SetName_DepartmentNull()
			{
				base[tablePayAccount.Name_DepartmentColumn] = Convert.DBNull;
			}

			[DebuggerNonUserCode]
			public bool IsBegin_AttendanceResultNull()
			{
				return IsNull(tablePayAccount.Begin_AttendanceResultColumn);
			}

			[DebuggerNonUserCode]
			public void SetBegin_AttendanceResultNull()
			{
				base[tablePayAccount.Begin_AttendanceResultColumn] = Convert.DBNull;
			}

			[DebuggerNonUserCode]
			public bool IsEnd_AttendanceResultNull()
			{
				return IsNull(tablePayAccount.End_AttendanceResultColumn);
			}

			[DebuggerNonUserCode]
			public void SetEnd_AttendanceResultNull()
			{
				base[tablePayAccount.End_AttendanceResultColumn] = Convert.DBNull;
			}

			[DebuggerNonUserCode]
			public bool IsFactDays_AttendanceResultNull()
			{
				return IsNull(tablePayAccount.FactDays_AttendanceResultColumn);
			}

			[DebuggerNonUserCode]
			public void SetFactDays_AttendanceResultNull()
			{
				base[tablePayAccount.FactDays_AttendanceResultColumn] = Convert.DBNull;
			}

			[DebuggerNonUserCode]
			public bool IsPayDays_PayAccountNull()
			{
				return IsNull(tablePayAccount.PayDays_PayAccountColumn);
			}

			[DebuggerNonUserCode]
			public void SetPayDays_PayAccountNull()
			{
				base[tablePayAccount.PayDays_PayAccountColumn] = Convert.DBNull;
			}

			[DebuggerNonUserCode]
			public bool IsName_CreatorNull()
			{
				return IsNull(tablePayAccount.Name_CreatorColumn);
			}

			[DebuggerNonUserCode]
			public void SetName_CreatorNull()
			{
				base[tablePayAccount.Name_CreatorColumn] = Convert.DBNull;
			}

			[DebuggerNonUserCode]
			public bool IsCreateDate_PayAccountNull()
			{
				return IsNull(tablePayAccount.CreateDate_PayAccountColumn);
			}

			[DebuggerNonUserCode]
			public void SetCreateDate_PayAccountNull()
			{
				base[tablePayAccount.CreateDate_PayAccountColumn] = Convert.DBNull;
			}

			[DebuggerNonUserCode]
			public bool IsName_AssessorNull()
			{
				return IsNull(tablePayAccount.Name_AssessorColumn);
			}

			[DebuggerNonUserCode]
			public void SetName_AssessorNull()
			{
				base[tablePayAccount.Name_AssessorColumn] = Convert.DBNull;
			}

			[DebuggerNonUserCode]
			public bool IsAssessDate_PayAccountNull()
			{
				return IsNull(tablePayAccount.AssessDate_PayAccountColumn);
			}

			[DebuggerNonUserCode]
			public void SetAssessDate_PayAccountNull()
			{
				base[tablePayAccount.AssessDate_PayAccountColumn] = Convert.DBNull;
			}

			[DebuggerNonUserCode]
			public bool IsLastModUserNameNull()
			{
				return IsNull(tablePayAccount.LastModUserNameColumn);
			}

			[DebuggerNonUserCode]
			public void SetLastModUserNameNull()
			{
				base[tablePayAccount.LastModUserNameColumn] = Convert.DBNull;
			}

			[DebuggerNonUserCode]
			public bool IsLastModDate_PayAccountNull()
			{
				return IsNull(tablePayAccount.LastModDate_PayAccountColumn);
			}

			[DebuggerNonUserCode]
			public void SetLastModDate_PayAccountNull()
			{
				base[tablePayAccount.LastModDate_PayAccountColumn] = Convert.DBNull;
			}
		}

		[GeneratedCode("System.Data.Design.TypedDataSetGenerator", "2.0.0.0")]
		public class PayAccountDataRow : DataRow
		{
			private PayAccountDataDataTable tablePayAccountData;

			[DebuggerNonUserCode]
			public string No_Employee
			{
				get
				{
					try
					{
						return (string)base[tablePayAccountData.No_EmployeeColumn];
					}
					catch (InvalidCastException innerException)
					{
						throw new StrongTypingException("The value for column 'No_Employee' in table 'PayAccountData' is DBNull.", innerException);
					}
				}
				set
				{
					base[tablePayAccountData.No_EmployeeColumn] = value;
				}
			}

			[DebuggerNonUserCode]
			public string Name_Employee
			{
				get
				{
					try
					{
						return (string)base[tablePayAccountData.Name_EmployeeColumn];
					}
					catch (InvalidCastException innerException)
					{
						throw new StrongTypingException("The value for column 'Name_Employee' in table 'PayAccountData' is DBNull.", innerException);
					}
				}
				set
				{
					base[tablePayAccountData.Name_EmployeeColumn] = value;
				}
			}

			[DebuggerNonUserCode]
			public decimal BasicPay_PayAccountData
			{
				get
				{
					try
					{
						return (decimal)base[tablePayAccountData.BasicPay_PayAccountDataColumn];
					}
					catch (InvalidCastException innerException)
					{
						throw new StrongTypingException("The value for column 'BasicPay_PayAccountData' in table 'PayAccountData' is DBNull.", innerException);
					}
				}
				set
				{
					base[tablePayAccountData.BasicPay_PayAccountDataColumn] = value;
				}
			}

			[DebuggerNonUserCode]
			public decimal OvertimePay_PayAccountData
			{
				get
				{
					try
					{
						return (decimal)base[tablePayAccountData.OvertimePay_PayAccountDataColumn];
					}
					catch (InvalidCastException innerException)
					{
						throw new StrongTypingException("The value for column 'OvertimePay_PayAccountData' in table 'PayAccountData' is DBNull.", innerException);
					}
				}
				set
				{
					base[tablePayAccountData.OvertimePay_PayAccountDataColumn] = value;
				}
			}

			[DebuggerNonUserCode]
			public decimal AttendanceBounty_PayAccountData
			{
				get
				{
					try
					{
						return (decimal)base[tablePayAccountData.AttendanceBounty_PayAccountDataColumn];
					}
					catch (InvalidCastException innerException)
					{
						throw new StrongTypingException("The value for column 'AttendanceBounty_PayAccountData' in table 'PayAccountData' is DBNull.", innerException);
					}
				}
				set
				{
					base[tablePayAccountData.AttendanceBounty_PayAccountDataColumn] = value;
				}
			}

			[DebuggerNonUserCode]
			public decimal Later_PayAccountData
			{
				get
				{
					try
					{
						return (decimal)base[tablePayAccountData.Later_PayAccountDataColumn];
					}
					catch (InvalidCastException innerException)
					{
						throw new StrongTypingException("The value for column 'Later_PayAccountData' in table 'PayAccountData' is DBNull.", innerException);
					}
				}
				set
				{
					base[tablePayAccountData.Later_PayAccountDataColumn] = value;
				}
			}

			[DebuggerNonUserCode]
			public decimal LeaveEarly_PayAccountData
			{
				get
				{
					try
					{
						return (decimal)base[tablePayAccountData.LeaveEarly_PayAccountDataColumn];
					}
					catch (InvalidCastException innerException)
					{
						throw new StrongTypingException("The value for column 'LeaveEarly_PayAccountData' in table 'PayAccountData' is DBNull.", innerException);
					}
				}
				set
				{
					base[tablePayAccountData.LeaveEarly_PayAccountDataColumn] = value;
				}
			}

			[DebuggerNonUserCode]
			public decimal Absent_PayAccountData
			{
				get
				{
					try
					{
						return (decimal)base[tablePayAccountData.Absent_PayAccountDataColumn];
					}
					catch (InvalidCastException innerException)
					{
						throw new StrongTypingException("The value for column 'Absent_PayAccountData' in table 'PayAccountData' is DBNull.", innerException);
					}
				}
				set
				{
					base[tablePayAccountData.Absent_PayAccountDataColumn] = value;
				}
			}

			[DebuggerNonUserCode]
			public decimal Sick_PayAccountData
			{
				get
				{
					try
					{
						return (decimal)base[tablePayAccountData.Sick_PayAccountDataColumn];
					}
					catch (InvalidCastException innerException)
					{
						throw new StrongTypingException("The value for column 'Sick_PayAccountData' in table 'PayAccountData' is DBNull.", innerException);
					}
				}
				set
				{
					base[tablePayAccountData.Sick_PayAccountDataColumn] = value;
				}
			}

			[DebuggerNonUserCode]
			public decimal Event_PayAccountData
			{
				get
				{
					try
					{
						return (decimal)base[tablePayAccountData.Event_PayAccountDataColumn];
					}
					catch (InvalidCastException innerException)
					{
						throw new StrongTypingException("The value for column 'Event_PayAccountData' in table 'PayAccountData' is DBNull.", innerException);
					}
				}
				set
				{
					base[tablePayAccountData.Event_PayAccountDataColumn] = value;
				}
			}

			[DebuggerNonUserCode]
			public decimal Provide_PayAccountData
			{
				get
				{
					try
					{
						return (decimal)base[tablePayAccountData.Provide_PayAccountDataColumn];
					}
					catch (InvalidCastException innerException)
					{
						throw new StrongTypingException("The value for column 'Provide_PayAccountData' in table 'PayAccountData' is DBNull.", innerException);
					}
				}
				set
				{
					base[tablePayAccountData.Provide_PayAccountDataColumn] = value;
				}
			}

			[DebuggerNonUserCode]
			public decimal Idleness_PayAccountData
			{
				get
				{
					try
					{
						return (decimal)base[tablePayAccountData.Idleness_PayAccountDataColumn];
					}
					catch (InvalidCastException innerException)
					{
						throw new StrongTypingException("The value for column 'Idleness_PayAccountData' in table 'PayAccountData' is DBNull.", innerException);
					}
				}
				set
				{
					base[tablePayAccountData.Idleness_PayAccountDataColumn] = value;
				}
			}

			[DebuggerNonUserCode]
			public decimal Medical_PayAccountData
			{
				get
				{
					try
					{
						return (decimal)base[tablePayAccountData.Medical_PayAccountDataColumn];
					}
					catch (InvalidCastException innerException)
					{
						throw new StrongTypingException("The value for column 'Medical_PayAccountData' in table 'PayAccountData' is DBNull.", innerException);
					}
				}
				set
				{
					base[tablePayAccountData.Medical_PayAccountDataColumn] = value;
				}
			}

			[DebuggerNonUserCode]
			public decimal AccumulationFund_PayAccountData
			{
				get
				{
					try
					{
						return (decimal)base[tablePayAccountData.AccumulationFund_PayAccountDataColumn];
					}
					catch (InvalidCastException innerException)
					{
						throw new StrongTypingException("The value for column 'AccumulationFund_PayAccountData' in table 'PayAccountData' is DBNull.", innerException);
					}
				}
				set
				{
					base[tablePayAccountData.AccumulationFund_PayAccountDataColumn] = value;
				}
			}

			[DebuggerNonUserCode]
			public decimal Bonus_PayAccountData
			{
				get
				{
					try
					{
						return (decimal)base[tablePayAccountData.Bonus_PayAccountDataColumn];
					}
					catch (InvalidCastException innerException)
					{
						throw new StrongTypingException("The value for column 'Bonus_PayAccountData' in table 'PayAccountData' is DBNull.", innerException);
					}
				}
				set
				{
					base[tablePayAccountData.Bonus_PayAccountDataColumn] = value;
				}
			}

			[DebuggerNonUserCode]
			public decimal Detain_PayAccountData
			{
				get
				{
					try
					{
						return (decimal)base[tablePayAccountData.Detain_PayAccountDataColumn];
					}
					catch (InvalidCastException innerException)
					{
						throw new StrongTypingException("The value for column 'Detain_PayAccountData' in table 'PayAccountData' is DBNull.", innerException);
					}
				}
				set
				{
					base[tablePayAccountData.Detain_PayAccountDataColumn] = value;
				}
			}

			[DebuggerNonUserCode]
			public decimal Total_PayAccountData
			{
				get
				{
					try
					{
						return (decimal)base[tablePayAccountData.Total_PayAccountDataColumn];
					}
					catch (InvalidCastException innerException)
					{
						throw new StrongTypingException("The value for column 'Total_PayAccountData' in table 'PayAccountData' is DBNull.", innerException);
					}
				}
				set
				{
					base[tablePayAccountData.Total_PayAccountDataColumn] = value;
				}
			}

			[DebuggerNonUserCode]
			public decimal Tax_PayAccountData
			{
				get
				{
					try
					{
						return (decimal)base[tablePayAccountData.Tax_PayAccountDataColumn];
					}
					catch (InvalidCastException innerException)
					{
						throw new StrongTypingException("The value for column 'Tax_PayAccountData' in table 'PayAccountData' is DBNull.", innerException);
					}
				}
				set
				{
					base[tablePayAccountData.Tax_PayAccountDataColumn] = value;
				}
			}

			[DebuggerNonUserCode]
			public decimal FactPay_PayAccountData
			{
				get
				{
					try
					{
						return (decimal)base[tablePayAccountData.FactPay_PayAccountDataColumn];
					}
					catch (InvalidCastException innerException)
					{
						throw new StrongTypingException("The value for column 'FactPay_PayAccountData' in table 'PayAccountData' is DBNull.", innerException);
					}
				}
				set
				{
					base[tablePayAccountData.FactPay_PayAccountDataColumn] = value;
				}
			}

			[DebuggerNonUserCode]
			public string Comment_PayAccountData
			{
				get
				{
					try
					{
						return (string)base[tablePayAccountData.Comment_PayAccountDataColumn];
					}
					catch (InvalidCastException innerException)
					{
						throw new StrongTypingException("The value for column 'Comment_PayAccountData' in table 'PayAccountData' is DBNull.", innerException);
					}
				}
				set
				{
					base[tablePayAccountData.Comment_PayAccountDataColumn] = value;
				}
			}

			[DebuggerNonUserCode]
			internal PayAccountDataRow(DataRowBuilder rb)
				: base(rb)
			{
				tablePayAccountData = (PayAccountDataDataTable)base.Table;
			}

			[DebuggerNonUserCode]
			public bool IsNo_EmployeeNull()
			{
				return IsNull(tablePayAccountData.No_EmployeeColumn);
			}

			[DebuggerNonUserCode]
			public void SetNo_EmployeeNull()
			{
				base[tablePayAccountData.No_EmployeeColumn] = Convert.DBNull;
			}

			[DebuggerNonUserCode]
			public bool IsName_EmployeeNull()
			{
				return IsNull(tablePayAccountData.Name_EmployeeColumn);
			}

			[DebuggerNonUserCode]
			public void SetName_EmployeeNull()
			{
				base[tablePayAccountData.Name_EmployeeColumn] = Convert.DBNull;
			}

			[DebuggerNonUserCode]
			public bool IsBasicPay_PayAccountDataNull()
			{
				return IsNull(tablePayAccountData.BasicPay_PayAccountDataColumn);
			}

			[DebuggerNonUserCode]
			public void SetBasicPay_PayAccountDataNull()
			{
				base[tablePayAccountData.BasicPay_PayAccountDataColumn] = Convert.DBNull;
			}

			[DebuggerNonUserCode]
			public bool IsOvertimePay_PayAccountDataNull()
			{
				return IsNull(tablePayAccountData.OvertimePay_PayAccountDataColumn);
			}

			[DebuggerNonUserCode]
			public void SetOvertimePay_PayAccountDataNull()
			{
				base[tablePayAccountData.OvertimePay_PayAccountDataColumn] = Convert.DBNull;
			}

			[DebuggerNonUserCode]
			public bool IsAttendanceBounty_PayAccountDataNull()
			{
				return IsNull(tablePayAccountData.AttendanceBounty_PayAccountDataColumn);
			}

			[DebuggerNonUserCode]
			public void SetAttendanceBounty_PayAccountDataNull()
			{
				base[tablePayAccountData.AttendanceBounty_PayAccountDataColumn] = Convert.DBNull;
			}

			[DebuggerNonUserCode]
			public bool IsLater_PayAccountDataNull()
			{
				return IsNull(tablePayAccountData.Later_PayAccountDataColumn);
			}

			[DebuggerNonUserCode]
			public void SetLater_PayAccountDataNull()
			{
				base[tablePayAccountData.Later_PayAccountDataColumn] = Convert.DBNull;
			}

			[DebuggerNonUserCode]
			public bool IsLeaveEarly_PayAccountDataNull()
			{
				return IsNull(tablePayAccountData.LeaveEarly_PayAccountDataColumn);
			}

			[DebuggerNonUserCode]
			public void SetLeaveEarly_PayAccountDataNull()
			{
				base[tablePayAccountData.LeaveEarly_PayAccountDataColumn] = Convert.DBNull;
			}

			[DebuggerNonUserCode]
			public bool IsAbsent_PayAccountDataNull()
			{
				return IsNull(tablePayAccountData.Absent_PayAccountDataColumn);
			}

			[DebuggerNonUserCode]
			public void SetAbsent_PayAccountDataNull()
			{
				base[tablePayAccountData.Absent_PayAccountDataColumn] = Convert.DBNull;
			}

			[DebuggerNonUserCode]
			public bool IsSick_PayAccountDataNull()
			{
				return IsNull(tablePayAccountData.Sick_PayAccountDataColumn);
			}

			[DebuggerNonUserCode]
			public void SetSick_PayAccountDataNull()
			{
				base[tablePayAccountData.Sick_PayAccountDataColumn] = Convert.DBNull;
			}

			[DebuggerNonUserCode]
			public bool IsEvent_PayAccountDataNull()
			{
				return IsNull(tablePayAccountData.Event_PayAccountDataColumn);
			}

			[DebuggerNonUserCode]
			public void SetEvent_PayAccountDataNull()
			{
				base[tablePayAccountData.Event_PayAccountDataColumn] = Convert.DBNull;
			}

			[DebuggerNonUserCode]
			public bool IsProvide_PayAccountDataNull()
			{
				return IsNull(tablePayAccountData.Provide_PayAccountDataColumn);
			}

			[DebuggerNonUserCode]
			public void SetProvide_PayAccountDataNull()
			{
				base[tablePayAccountData.Provide_PayAccountDataColumn] = Convert.DBNull;
			}

			[DebuggerNonUserCode]
			public bool IsIdleness_PayAccountDataNull()
			{
				return IsNull(tablePayAccountData.Idleness_PayAccountDataColumn);
			}

			[DebuggerNonUserCode]
			public void SetIdleness_PayAccountDataNull()
			{
				base[tablePayAccountData.Idleness_PayAccountDataColumn] = Convert.DBNull;
			}

			[DebuggerNonUserCode]
			public bool IsMedical_PayAccountDataNull()
			{
				return IsNull(tablePayAccountData.Medical_PayAccountDataColumn);
			}

			[DebuggerNonUserCode]
			public void SetMedical_PayAccountDataNull()
			{
				base[tablePayAccountData.Medical_PayAccountDataColumn] = Convert.DBNull;
			}

			[DebuggerNonUserCode]
			public bool IsAccumulationFund_PayAccountDataNull()
			{
				return IsNull(tablePayAccountData.AccumulationFund_PayAccountDataColumn);
			}

			[DebuggerNonUserCode]
			public void SetAccumulationFund_PayAccountDataNull()
			{
				base[tablePayAccountData.AccumulationFund_PayAccountDataColumn] = Convert.DBNull;
			}

			[DebuggerNonUserCode]
			public bool IsBonus_PayAccountDataNull()
			{
				return IsNull(tablePayAccountData.Bonus_PayAccountDataColumn);
			}

			[DebuggerNonUserCode]
			public void SetBonus_PayAccountDataNull()
			{
				base[tablePayAccountData.Bonus_PayAccountDataColumn] = Convert.DBNull;
			}

			[DebuggerNonUserCode]
			public bool IsDetain_PayAccountDataNull()
			{
				return IsNull(tablePayAccountData.Detain_PayAccountDataColumn);
			}

			[DebuggerNonUserCode]
			public void SetDetain_PayAccountDataNull()
			{
				base[tablePayAccountData.Detain_PayAccountDataColumn] = Convert.DBNull;
			}

			[DebuggerNonUserCode]
			public bool IsTotal_PayAccountDataNull()
			{
				return IsNull(tablePayAccountData.Total_PayAccountDataColumn);
			}

			[DebuggerNonUserCode]
			public void SetTotal_PayAccountDataNull()
			{
				base[tablePayAccountData.Total_PayAccountDataColumn] = Convert.DBNull;
			}

			[DebuggerNonUserCode]
			public bool IsTax_PayAccountDataNull()
			{
				return IsNull(tablePayAccountData.Tax_PayAccountDataColumn);
			}

			[DebuggerNonUserCode]
			public void SetTax_PayAccountDataNull()
			{
				base[tablePayAccountData.Tax_PayAccountDataColumn] = Convert.DBNull;
			}

			[DebuggerNonUserCode]
			public bool IsFactPay_PayAccountDataNull()
			{
				return IsNull(tablePayAccountData.FactPay_PayAccountDataColumn);
			}

			[DebuggerNonUserCode]
			public void SetFactPay_PayAccountDataNull()
			{
				base[tablePayAccountData.FactPay_PayAccountDataColumn] = Convert.DBNull;
			}

			[DebuggerNonUserCode]
			public bool IsComment_PayAccountDataNull()
			{
				return IsNull(tablePayAccountData.Comment_PayAccountDataColumn);
			}

			[DebuggerNonUserCode]
			public void SetComment_PayAccountDataNull()
			{
				base[tablePayAccountData.Comment_PayAccountDataColumn] = Convert.DBNull;
			}
		}

		[GeneratedCode("System.Data.Design.TypedDataSetGenerator", "2.0.0.0")]
		public class PayAccountRowChangeEvent : EventArgs
		{
			private PayAccountRow eventRow;

			private DataRowAction eventAction;

			[DebuggerNonUserCode]
			public PayAccountRow Row => eventRow;

			[DebuggerNonUserCode]
			public DataRowAction Action => eventAction;

			[DebuggerNonUserCode]
			public PayAccountRowChangeEvent(PayAccountRow row, DataRowAction action)
			{
				eventRow = row;
				eventAction = action;
			}
		}

		[GeneratedCode("System.Data.Design.TypedDataSetGenerator", "2.0.0.0")]
		public class PayAccountDataRowChangeEvent : EventArgs
		{
			private PayAccountDataRow eventRow;

			private DataRowAction eventAction;

			[DebuggerNonUserCode]
			public PayAccountDataRow Row => eventRow;

			[DebuggerNonUserCode]
			public DataRowAction Action => eventAction;

			[DebuggerNonUserCode]
			public PayAccountDataRowChangeEvent(PayAccountDataRow row, DataRowAction action)
			{
				eventRow = row;
				eventAction = action;
			}
		}

		private PayAccountDataTable tablePayAccount;

		private PayAccountDataDataTable tablePayAccountData;

		private SchemaSerializationMode _schemaSerializationMode = SchemaSerializationMode.IncludeSchema;

		[DebuggerNonUserCode]
		[Browsable(false)]
		[DesignerSerializationVisibility(DesignerSerializationVisibility.Content)]
		public PayAccountDataTable PayAccount => tablePayAccount;

		[DebuggerNonUserCode]
		[DesignerSerializationVisibility(DesignerSerializationVisibility.Content)]
		[Browsable(false)]
		public PayAccountDataDataTable PayAccountData => tablePayAccountData;

		[DesignerSerializationVisibility(DesignerSerializationVisibility.Visible)]
		[DebuggerNonUserCode]
		[Browsable(true)]
		public override SchemaSerializationMode SchemaSerializationMode
		{
			get
			{
				return _schemaSerializationMode;
			}
			set
			{
				_schemaSerializationMode = value;
			}
		}

		[DesignerSerializationVisibility(DesignerSerializationVisibility.Hidden)]
		[DebuggerNonUserCode]
		public new DataTableCollection Tables => base.Tables;

		[DesignerSerializationVisibility(DesignerSerializationVisibility.Hidden)]
		[DebuggerNonUserCode]
		public new DataRelationCollection Relations => base.Relations;

		[DebuggerNonUserCode]
		public dsFrmPayAccount()
		{
			BeginInit();
			InitClass();
			CollectionChangeEventHandler value = SchemaChanged;
			base.Tables.CollectionChanged += value;
			base.Relations.CollectionChanged += value;
			EndInit();
		}

		[DebuggerNonUserCode]
		protected dsFrmPayAccount(SerializationInfo info, StreamingContext context)
			: base(info, context, ConstructSchema: false)
		{
			if (IsBinarySerialized(info, context))
			{
				InitVars(initTable: false);
				CollectionChangeEventHandler value = SchemaChanged;
				Tables.CollectionChanged += value;
				Relations.CollectionChanged += value;
				return;
			}
			string s = (string)info.GetValue("XmlSchema", typeof(string));
			if (DetermineSchemaSerializationMode(info, context) == SchemaSerializationMode.IncludeSchema)
			{
				DataSet dataSet = new DataSet();
				dataSet.ReadXmlSchema(new XmlTextReader(new StringReader(s)));
				if (dataSet.Tables["PayAccount"] != null)
				{
					base.Tables.Add(new PayAccountDataTable(dataSet.Tables["PayAccount"]));
				}
				if (dataSet.Tables["PayAccountData"] != null)
				{
					base.Tables.Add(new PayAccountDataDataTable(dataSet.Tables["PayAccountData"]));
				}
				base.DataSetName = dataSet.DataSetName;
				base.Prefix = dataSet.Prefix;
				base.Namespace = dataSet.Namespace;
				base.Locale = dataSet.Locale;
				base.CaseSensitive = dataSet.CaseSensitive;
				base.EnforceConstraints = dataSet.EnforceConstraints;
				Merge(dataSet, preserveChanges: false, MissingSchemaAction.Add);
				InitVars();
			}
			else
			{
				ReadXmlSchema(new XmlTextReader(new StringReader(s)));
			}
			GetSerializationData(info, context);
			CollectionChangeEventHandler value2 = SchemaChanged;
			base.Tables.CollectionChanged += value2;
			Relations.CollectionChanged += value2;
		}

		[DebuggerNonUserCode]
		protected override void InitializeDerivedDataSet()
		{
			BeginInit();
			InitClass();
			EndInit();
		}

		[DebuggerNonUserCode]
		public override DataSet Clone()
		{
			dsFrmPayAccount dsFrmPayAccount = (dsFrmPayAccount)base.Clone();
			dsFrmPayAccount.InitVars();
			dsFrmPayAccount.SchemaSerializationMode = SchemaSerializationMode;
			return dsFrmPayAccount;
		}

		[DebuggerNonUserCode]
		protected override bool ShouldSerializeTables()
		{
			return false;
		}

		[DebuggerNonUserCode]
		protected override bool ShouldSerializeRelations()
		{
			return false;
		}

		[DebuggerNonUserCode]
		protected override void ReadXmlSerializable(XmlReader reader)
		{
			if (DetermineSchemaSerializationMode(reader) == SchemaSerializationMode.IncludeSchema)
			{
				Reset();
				DataSet dataSet = new DataSet();
				dataSet.ReadXml(reader);
				if (dataSet.Tables["PayAccount"] != null)
				{
					base.Tables.Add(new PayAccountDataTable(dataSet.Tables["PayAccount"]));
				}
				if (dataSet.Tables["PayAccountData"] != null)
				{
					base.Tables.Add(new PayAccountDataDataTable(dataSet.Tables["PayAccountData"]));
				}
				base.DataSetName = dataSet.DataSetName;
				base.Prefix = dataSet.Prefix;
				base.Namespace = dataSet.Namespace;
				base.Locale = dataSet.Locale;
				base.CaseSensitive = dataSet.CaseSensitive;
				base.EnforceConstraints = dataSet.EnforceConstraints;
				Merge(dataSet, preserveChanges: false, MissingSchemaAction.Add);
				InitVars();
			}
			else
			{
				ReadXml(reader);
				InitVars();
			}
		}

		[DebuggerNonUserCode]
		protected override XmlSchema GetSchemaSerializable()
		{
			MemoryStream memoryStream = new MemoryStream();
			WriteXmlSchema(new XmlTextWriter(memoryStream, null));
			memoryStream.Position = 0L;
			return XmlSchema.Read(new XmlTextReader(memoryStream), null);
		}

		[DebuggerNonUserCode]
		internal void InitVars()
		{
			InitVars(initTable: true);
		}

		[DebuggerNonUserCode]
		internal void InitVars(bool initTable)
		{
			tablePayAccount = (PayAccountDataTable)base.Tables["PayAccount"];
			if (initTable && tablePayAccount != null)
			{
				tablePayAccount.InitVars();
			}
			tablePayAccountData = (PayAccountDataDataTable)base.Tables["PayAccountData"];
			if (initTable && tablePayAccountData != null)
			{
				tablePayAccountData.InitVars();
			}
		}

		[DebuggerNonUserCode]
		private void InitClass()
		{
			base.DataSetName = "dsFrmPayAccount";
			base.Prefix = "";
			base.Namespace = "http://tempuri.org/dsFrmPayAccount.xsd";
			base.EnforceConstraints = true;
			SchemaSerializationMode = SchemaSerializationMode.IncludeSchema;
			tablePayAccount = new PayAccountDataTable();
			base.Tables.Add(tablePayAccount);
			tablePayAccountData = new PayAccountDataDataTable();
			base.Tables.Add(tablePayAccountData);
		}

		[DebuggerNonUserCode]
		private bool ShouldSerializePayAccount()
		{
			return false;
		}

		[DebuggerNonUserCode]
		private bool ShouldSerializePayAccountData()
		{
			return false;
		}

		[DebuggerNonUserCode]
		private void SchemaChanged(object sender, CollectionChangeEventArgs e)
		{
			if (e.Action == CollectionChangeAction.Remove)
			{
				InitVars();
			}
		}

		[DebuggerNonUserCode]
		public static XmlSchemaComplexType GetTypedDataSetSchema(XmlSchemaSet xs)
		{
			dsFrmPayAccount dsFrmPayAccount = new dsFrmPayAccount();
			XmlSchemaComplexType xmlSchemaComplexType = new XmlSchemaComplexType();
			XmlSchemaSequence xmlSchemaSequence = new XmlSchemaSequence();
			XmlSchemaAny xmlSchemaAny = new XmlSchemaAny();
			xmlSchemaAny.Namespace = dsFrmPayAccount.Namespace;
			xmlSchemaSequence.Items.Add(xmlSchemaAny);
			xmlSchemaComplexType.Particle = xmlSchemaSequence;
			XmlSchema schemaSerializable = dsFrmPayAccount.GetSchemaSerializable();
			if (xs.Contains(schemaSerializable.TargetNamespace))
			{
				MemoryStream memoryStream = new MemoryStream();
				MemoryStream memoryStream2 = new MemoryStream();
				try
				{
					XmlSchema xmlSchema = null;
					schemaSerializable.Write(memoryStream);
					IEnumerator enumerator = xs.Schemas(schemaSerializable.TargetNamespace).GetEnumerator();
					while (enumerator.MoveNext())
					{
						xmlSchema = (XmlSchema)enumerator.Current;
						memoryStream2.SetLength(0L);
						xmlSchema.Write(memoryStream2);
						if (memoryStream.Length == memoryStream2.Length)
						{
							memoryStream.Position = 0L;
							memoryStream2.Position = 0L;
							while (memoryStream.Position != memoryStream.Length && memoryStream.ReadByte() == memoryStream2.ReadByte())
							{
							}
							if (memoryStream.Position == memoryStream.Length)
							{
								return xmlSchemaComplexType;
							}
						}
					}
				}
				finally
				{
					memoryStream?.Close();
					memoryStream2?.Close();
				}
			}
			xs.Add(schemaSerializable);
			return xmlSchemaComplexType;
		}
	}
}