sanlu_new/sanlu_c#/SunRoxmServer/SunRoxm.BizPeri.ReportDataSet/SunRoxm.BizPeri.ReportDataSet.ReportDataSet/dsFrmRegionalLeader.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]
	[HelpKeyword("vs.data.DataSet")]
	[GeneratedCode("System.Data.Design.TypedDataSetGenerator", "2.0.0.0")]
	[XmlRoot("dsFrmRegionalLeader")]
	[DesignerCategory("code")]
	[ToolboxItem(true)]
	[XmlSchemaProvider("GetTypedDataSetSchema")]
	public class dsFrmRegionalLeader : DataSet
	{
		public delegate void RegionalLeaderRowChangeEventHandler(object sender, RegionalLeaderRowChangeEvent e);

		public delegate void EmployeeRowChangeEventHandler(object sender, EmployeeRowChangeEvent e);

		public delegate void PrincipalRowChangeEventHandler(object sender, PrincipalRowChangeEvent e);

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

			private DataColumn columnName_RegionalLeader;

			[DebuggerNonUserCode]
			public DataColumn No_RegionalLeaderColumn => columnNo_RegionalLeader;

			[DebuggerNonUserCode]
			public DataColumn Name_RegionalLeaderColumn => columnName_RegionalLeader;

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

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

			public event RegionalLeaderRowChangeEventHandler RegionalLeaderRowChanging;

			public event RegionalLeaderRowChangeEventHandler RegionalLeaderRowChanged;

			public event RegionalLeaderRowChangeEventHandler RegionalLeaderRowDeleting;

			public event RegionalLeaderRowChangeEventHandler RegionalLeaderRowDeleted;

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

			[DebuggerNonUserCode]
			internal RegionalLeaderDataTable(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 RegionalLeaderDataTable(SerializationInfo info, StreamingContext context)
				: base(info, context)
			{
				InitVars();
			}

			[DebuggerNonUserCode]
			public void AddRegionalLeaderRow(RegionalLeaderRow row)
			{
				base.Rows.Add(row);
			}

			[DebuggerNonUserCode]
			public RegionalLeaderRow AddRegionalLeaderRow(string No_RegionalLeader, string Name_RegionalLeader)
			{
				RegionalLeaderRow regionalLeaderRow = (RegionalLeaderRow)NewRow();
				object[] array2 = regionalLeaderRow.ItemArray = new object[2]
				{
					No_RegionalLeader,
					Name_RegionalLeader
				};
				base.Rows.Add(regionalLeaderRow);
				return regionalLeaderRow;
			}

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

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

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

			[DebuggerNonUserCode]
			internal void InitVars()
			{
				columnNo_RegionalLeader = base.Columns["No_RegionalLeader"];
				columnName_RegionalLeader = base.Columns["Name_RegionalLeader"];
			}

			[DebuggerNonUserCode]
			private void InitClass()
			{
				columnNo_RegionalLeader = new DataColumn("No_RegionalLeader", typeof(string), null, MappingType.Element);
				base.Columns.Add(columnNo_RegionalLeader);
				columnName_RegionalLeader = new DataColumn("Name_RegionalLeader", typeof(string), null, MappingType.Element);
				base.Columns.Add(columnName_RegionalLeader);
				columnNo_RegionalLeader.Caption = "Name_Telephone";
				columnName_RegionalLeader.Caption = "No_Telephone";
			}

			[DebuggerNonUserCode]
			public RegionalLeaderRow NewRegionalLeaderRow()
			{
				return (RegionalLeaderRow)NewRow();
			}

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

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

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

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

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

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

			[DebuggerNonUserCode]
			public void RemoveRegionalLeaderRow(RegionalLeaderRow row)
			{
				base.Rows.Remove(row);
			}

			[DebuggerNonUserCode]
			public static XmlSchemaComplexType GetTypedTableSchema(XmlSchemaSet xs)
			{
				XmlSchemaComplexType xmlSchemaComplexType = new XmlSchemaComplexType();
				XmlSchemaSequence xmlSchemaSequence = new XmlSchemaSequence();
				dsFrmRegionalLeader dsFrmRegionalLeader = new dsFrmRegionalLeader();
				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 = dsFrmRegionalLeader.Namespace;
				xmlSchemaComplexType.Attributes.Add(xmlSchemaAttribute);
				XmlSchemaAttribute xmlSchemaAttribute2 = new XmlSchemaAttribute();
				xmlSchemaAttribute2.Name = "tableTypeName";
				xmlSchemaAttribute2.FixedValue = "RegionalLeaderDataTable";
				xmlSchemaComplexType.Attributes.Add(xmlSchemaAttribute2);
				xmlSchemaComplexType.Particle = xmlSchemaSequence;
				XmlSchema schemaSerializable = dsFrmRegionalLeader.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 EmployeeDataTable : DataTable, IEnumerable
		{
			private DataColumn columnNo_Employee;

			private DataColumn columnName_Employee;

			private DataColumn columnEmployeeNo_Employee;

			private DataColumn columnNameEng_Employee;

			private DataColumn columnGender_Employee;

			private DataColumn columnCountry_Employee;

			private DataColumn columnHomeplace_Employee;

			private DataColumn columnNation_Employee;

			private DataColumn columnIDNo_Employee;

			private DataColumn columnPassport_Employee;

			private DataColumn columnIsMarried_Employee;

			private DataColumn columnCreateDate_Employee;

			private DataColumn columnDuty_Employee;

			private DataColumn columnProbation_Employee;

			private DataColumn columnOnJobDate_Employee;

			private DataColumn columnOnDuty_Employee;

			private DataColumn columnObJobStatus_Employee;

			private DataColumn columnOffDuty_Employee;

			private DataColumn columnSuspendDate_Employee;

			private DataColumn columnTel_Employee;

			private DataColumn columnEMail_Employee;

			private DataColumn columnAddress_Employee;

			private DataColumn columnComment_Employee;

			private DataColumn columnLastModDate_Employee;

			[DebuggerNonUserCode]
			public DataColumn No_EmployeeColumn => columnNo_Employee;

			[DebuggerNonUserCode]
			public DataColumn Name_EmployeeColumn => columnName_Employee;

			[DebuggerNonUserCode]
			public DataColumn EmployeeNo_EmployeeColumn => columnEmployeeNo_Employee;

			[DebuggerNonUserCode]
			public DataColumn NameEng_EmployeeColumn => columnNameEng_Employee;

			[DebuggerNonUserCode]
			public DataColumn Gender_EmployeeColumn => columnGender_Employee;

			[DebuggerNonUserCode]
			public DataColumn Country_EmployeeColumn => columnCountry_Employee;

			[DebuggerNonUserCode]
			public DataColumn Homeplace_EmployeeColumn => columnHomeplace_Employee;

			[DebuggerNonUserCode]
			public DataColumn Nation_EmployeeColumn => columnNation_Employee;

			[DebuggerNonUserCode]
			public DataColumn IDNo_EmployeeColumn => columnIDNo_Employee;

			[DebuggerNonUserCode]
			public DataColumn Passport_EmployeeColumn => columnPassport_Employee;

			[DebuggerNonUserCode]
			public DataColumn IsMarried_EmployeeColumn => columnIsMarried_Employee;

			[DebuggerNonUserCode]
			public DataColumn CreateDate_EmployeeColumn => columnCreateDate_Employee;

			[DebuggerNonUserCode]
			public DataColumn Duty_EmployeeColumn => columnDuty_Employee;

			[DebuggerNonUserCode]
			public DataColumn Probation_EmployeeColumn => columnProbation_Employee;

			[DebuggerNonUserCode]
			public DataColumn OnJobDate_EmployeeColumn => columnOnJobDate_Employee;

			[DebuggerNonUserCode]
			public DataColumn OnDuty_EmployeeColumn => columnOnDuty_Employee;

			[DebuggerNonUserCode]
			public DataColumn ObJobStatus_EmployeeColumn => columnObJobStatus_Employee;

			[DebuggerNonUserCode]
			public DataColumn OffDuty_EmployeeColumn => columnOffDuty_Employee;

			[DebuggerNonUserCode]
			public DataColumn SuspendDate_EmployeeColumn => columnSuspendDate_Employee;

			[DebuggerNonUserCode]
			public DataColumn Tel_EmployeeColumn => columnTel_Employee;

			[DebuggerNonUserCode]
			public DataColumn EMail_EmployeeColumn => columnEMail_Employee;

			[DebuggerNonUserCode]
			public DataColumn Address_EmployeeColumn => columnAddress_Employee;

			[DebuggerNonUserCode]
			public DataColumn Comment_EmployeeColumn => columnComment_Employee;

			[DebuggerNonUserCode]
			public DataColumn LastModDate_EmployeeColumn => columnLastModDate_Employee;

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

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

			public event EmployeeRowChangeEventHandler EmployeeRowChanging;

			public event EmployeeRowChangeEventHandler EmployeeRowChanged;

			public event EmployeeRowChangeEventHandler EmployeeRowDeleting;

			public event EmployeeRowChangeEventHandler EmployeeRowDeleted;

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

			[DebuggerNonUserCode]
			internal EmployeeDataTable(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 EmployeeDataTable(SerializationInfo info, StreamingContext context)
				: base(info, context)
			{
				InitVars();
			}

			[DebuggerNonUserCode]
			public void AddEmployeeRow(EmployeeRow row)
			{
				base.Rows.Add(row);
			}

			[DebuggerNonUserCode]
			public EmployeeRow AddEmployeeRow(string No_Employee, string Name_Employee, string EmployeeNo_Employee, string NameEng_Employee, bool Gender_Employee, int Country_Employee, string Homeplace_Employee, string Nation_Employee, string IDNo_Employee, string Passport_Employee, bool IsMarried_Employee, DateTime CreateDate_Employee, string Duty_Employee, decimal Probation_Employee, DateTime OnJobDate_Employee, DateTime OnDuty_Employee, int ObJobStatus_Employee, DateTime OffDuty_Employee, DateTime SuspendDate_Employee, string Tel_Employee, string EMail_Employee, string Address_Employee, string Comment_Employee, DateTime LastModDate_Employee)
			{
				EmployeeRow employeeRow = (EmployeeRow)NewRow();
				object[] array2 = employeeRow.ItemArray = new object[24]
				{
					No_Employee,
					Name_Employee,
					EmployeeNo_Employee,
					NameEng_Employee,
					Gender_Employee,
					Country_Employee,
					Homeplace_Employee,
					Nation_Employee,
					IDNo_Employee,
					Passport_Employee,
					IsMarried_Employee,
					CreateDate_Employee,
					Duty_Employee,
					Probation_Employee,
					OnJobDate_Employee,
					OnDuty_Employee,
					ObJobStatus_Employee,
					OffDuty_Employee,
					SuspendDate_Employee,
					Tel_Employee,
					EMail_Employee,
					Address_Employee,
					Comment_Employee,
					LastModDate_Employee
				};
				base.Rows.Add(employeeRow);
				return employeeRow;
			}

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

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

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

			[DebuggerNonUserCode]
			internal void InitVars()
			{
				columnNo_Employee = base.Columns["No_Employee"];
				columnName_Employee = base.Columns["Name_Employee"];
				columnEmployeeNo_Employee = base.Columns["EmployeeNo_Employee"];
				columnNameEng_Employee = base.Columns["NameEng_Employee"];
				columnGender_Employee = base.Columns["Gender_Employee"];
				columnCountry_Employee = base.Columns["Country_Employee"];
				columnHomeplace_Employee = base.Columns["Homeplace_Employee"];
				columnNation_Employee = base.Columns["Nation_Employee"];
				columnIDNo_Employee = base.Columns["IDNo_Employee"];
				columnPassport_Employee = base.Columns["Passport_Employee"];
				columnIsMarried_Employee = base.Columns["IsMarried_Employee"];
				columnCreateDate_Employee = base.Columns["CreateDate_Employee"];
				columnDuty_Employee = base.Columns["Duty_Employee"];
				columnProbation_Employee = base.Columns["Probation_Employee"];
				columnOnJobDate_Employee = base.Columns["OnJobDate_Employee"];
				columnOnDuty_Employee = base.Columns["OnDuty_Employee"];
				columnObJobStatus_Employee = base.Columns["ObJobStatus_Employee"];
				columnOffDuty_Employee = base.Columns["OffDuty_Employee"];
				columnSuspendDate_Employee = base.Columns["SuspendDate_Employee"];
				columnTel_Employee = base.Columns["Tel_Employee"];
				columnEMail_Employee = base.Columns["EMail_Employee"];
				columnAddress_Employee = base.Columns["Address_Employee"];
				columnComment_Employee = base.Columns["Comment_Employee"];
				columnLastModDate_Employee = base.Columns["LastModDate_Employee"];
			}

			[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);
				columnEmployeeNo_Employee = new DataColumn("EmployeeNo_Employee", typeof(string), null, MappingType.Element);
				base.Columns.Add(columnEmployeeNo_Employee);
				columnNameEng_Employee = new DataColumn("NameEng_Employee", typeof(string), null, MappingType.Element);
				base.Columns.Add(columnNameEng_Employee);
				columnGender_Employee = new DataColumn("Gender_Employee", typeof(bool), null, MappingType.Element);
				base.Columns.Add(columnGender_Employee);
				columnCountry_Employee = new DataColumn("Country_Employee", typeof(int), null, MappingType.Element);
				base.Columns.Add(columnCountry_Employee);
				columnHomeplace_Employee = new DataColumn("Homeplace_Employee", typeof(string), null, MappingType.Element);
				base.Columns.Add(columnHomeplace_Employee);
				columnNation_Employee = new DataColumn("Nation_Employee", typeof(string), null, MappingType.Element);
				base.Columns.Add(columnNation_Employee);
				columnIDNo_Employee = new DataColumn("IDNo_Employee", typeof(string), null, MappingType.Element);
				base.Columns.Add(columnIDNo_Employee);
				columnPassport_Employee = new DataColumn("Passport_Employee", typeof(string), null, MappingType.Element);
				base.Columns.Add(columnPassport_Employee);
				columnIsMarried_Employee = new DataColumn("IsMarried_Employee", typeof(bool), null, MappingType.Element);
				base.Columns.Add(columnIsMarried_Employee);
				columnCreateDate_Employee = new DataColumn("CreateDate_Employee", typeof(DateTime), null, MappingType.Element);
				base.Columns.Add(columnCreateDate_Employee);
				columnDuty_Employee = new DataColumn("Duty_Employee", typeof(string), null, MappingType.Element);
				base.Columns.Add(columnDuty_Employee);
				columnProbation_Employee = new DataColumn("Probation_Employee", typeof(decimal), null, MappingType.Element);
				base.Columns.Add(columnProbation_Employee);
				columnOnJobDate_Employee = new DataColumn("OnJobDate_Employee", typeof(DateTime), null, MappingType.Element);
				base.Columns.Add(columnOnJobDate_Employee);
				columnOnDuty_Employee = new DataColumn("OnDuty_Employee", typeof(DateTime), null, MappingType.Element);
				base.Columns.Add(columnOnDuty_Employee);
				columnObJobStatus_Employee = new DataColumn("ObJobStatus_Employee", typeof(int), null, MappingType.Element);
				base.Columns.Add(columnObJobStatus_Employee);
				columnOffDuty_Employee = new DataColumn("OffDuty_Employee", typeof(DateTime), null, MappingType.Element);
				base.Columns.Add(columnOffDuty_Employee);
				columnSuspendDate_Employee = new DataColumn("SuspendDate_Employee", typeof(DateTime), null, MappingType.Element);
				base.Columns.Add(columnSuspendDate_Employee);
				columnTel_Employee = new DataColumn("Tel_Employee", typeof(string), null, MappingType.Element);
				base.Columns.Add(columnTel_Employee);
				columnEMail_Employee = new DataColumn("EMail_Employee", typeof(string), null, MappingType.Element);
				base.Columns.Add(columnEMail_Employee);
				columnAddress_Employee = new DataColumn("Address_Employee", typeof(string), null, MappingType.Element);
				base.Columns.Add(columnAddress_Employee);
				columnComment_Employee = new DataColumn("Comment_Employee", typeof(string), null, MappingType.Element);
				base.Columns.Add(columnComment_Employee);
				columnLastModDate_Employee = new DataColumn("LastModDate_Employee", typeof(DateTime), null, MappingType.Element);
				base.Columns.Add(columnLastModDate_Employee);
			}

			[DebuggerNonUserCode]
			public EmployeeRow NewEmployeeRow()
			{
				return (EmployeeRow)NewRow();
			}

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

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

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

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

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

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

			[DebuggerNonUserCode]
			public void RemoveEmployeeRow(EmployeeRow row)
			{
				base.Rows.Remove(row);
			}

			[DebuggerNonUserCode]
			public static XmlSchemaComplexType GetTypedTableSchema(XmlSchemaSet xs)
			{
				XmlSchemaComplexType xmlSchemaComplexType = new XmlSchemaComplexType();
				XmlSchemaSequence xmlSchemaSequence = new XmlSchemaSequence();
				dsFrmRegionalLeader dsFrmRegionalLeader = new dsFrmRegionalLeader();
				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 = dsFrmRegionalLeader.Namespace;
				xmlSchemaComplexType.Attributes.Add(xmlSchemaAttribute);
				XmlSchemaAttribute xmlSchemaAttribute2 = new XmlSchemaAttribute();
				xmlSchemaAttribute2.Name = "tableTypeName";
				xmlSchemaAttribute2.FixedValue = "EmployeeDataTable";
				xmlSchemaComplexType.Attributes.Add(xmlSchemaAttribute2);
				xmlSchemaComplexType.Particle = xmlSchemaSequence;
				XmlSchema schemaSerializable = dsFrmRegionalLeader.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]
		[XmlSchemaProvider("GetTypedTableSchema")]
		[GeneratedCode("System.Data.Design.TypedDataSetGenerator", "2.0.0.0")]
		public class PrincipalDataTable : DataTable, IEnumerable
		{
			private DataColumn columnIsMain_Principal;

			private DataColumn columnComment_Principal;

			private DataColumn columnName_Employee;

			private DataColumn columnNo_Employee;

			[DebuggerNonUserCode]
			public DataColumn IsMain_PrincipalColumn => columnIsMain_Principal;

			[DebuggerNonUserCode]
			public DataColumn Comment_PrincipalColumn => columnComment_Principal;

			[DebuggerNonUserCode]
			public DataColumn Name_EmployeeColumn => columnName_Employee;

			[DebuggerNonUserCode]
			public DataColumn No_EmployeeColumn => columnNo_Employee;

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

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

			public event PrincipalRowChangeEventHandler PrincipalRowChanging;

			public event PrincipalRowChangeEventHandler PrincipalRowChanged;

			public event PrincipalRowChangeEventHandler PrincipalRowDeleting;

			public event PrincipalRowChangeEventHandler PrincipalRowDeleted;

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

			[DebuggerNonUserCode]
			internal PrincipalDataTable(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 PrincipalDataTable(SerializationInfo info, StreamingContext context)
				: base(info, context)
			{
				InitVars();
			}

			[DebuggerNonUserCode]
			public void AddPrincipalRow(PrincipalRow row)
			{
				base.Rows.Add(row);
			}

			[DebuggerNonUserCode]
			public PrincipalRow AddPrincipalRow(bool IsMain_Principal, string Comment_Principal, string Name_Employee, string No_Employee)
			{
				PrincipalRow principalRow = (PrincipalRow)NewRow();
				object[] array2 = principalRow.ItemArray = new object[4]
				{
					IsMain_Principal,
					Comment_Principal,
					Name_Employee,
					No_Employee
				};
				base.Rows.Add(principalRow);
				return principalRow;
			}

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

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

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

			[DebuggerNonUserCode]
			internal void InitVars()
			{
				columnIsMain_Principal = base.Columns["IsMain_Principal"];
				columnComment_Principal = base.Columns["Comment_Principal"];
				columnName_Employee = base.Columns["Name_Employee"];
				columnNo_Employee = base.Columns["No_Employee"];
			}

			[DebuggerNonUserCode]
			private void InitClass()
			{
				columnIsMain_Principal = new DataColumn("IsMain_Principal", typeof(bool), null, MappingType.Element);
				base.Columns.Add(columnIsMain_Principal);
				columnComment_Principal = new DataColumn("Comment_Principal", typeof(string), null, MappingType.Element);
				base.Columns.Add(columnComment_Principal);
				columnName_Employee = new DataColumn("Name_Employee", typeof(string), null, MappingType.Element);
				base.Columns.Add(columnName_Employee);
				columnNo_Employee = new DataColumn("No_Employee", typeof(string), null, MappingType.Element);
				base.Columns.Add(columnNo_Employee);
			}

			[DebuggerNonUserCode]
			public PrincipalRow NewPrincipalRow()
			{
				return (PrincipalRow)NewRow();
			}

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

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

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

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

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

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

			[DebuggerNonUserCode]
			public void RemovePrincipalRow(PrincipalRow row)
			{
				base.Rows.Remove(row);
			}

			[DebuggerNonUserCode]
			public static XmlSchemaComplexType GetTypedTableSchema(XmlSchemaSet xs)
			{
				XmlSchemaComplexType xmlSchemaComplexType = new XmlSchemaComplexType();
				XmlSchemaSequence xmlSchemaSequence = new XmlSchemaSequence();
				dsFrmRegionalLeader dsFrmRegionalLeader = new dsFrmRegionalLeader();
				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 = dsFrmRegionalLeader.Namespace;
				xmlSchemaComplexType.Attributes.Add(xmlSchemaAttribute);
				XmlSchemaAttribute xmlSchemaAttribute2 = new XmlSchemaAttribute();
				xmlSchemaAttribute2.Name = "tableTypeName";
				xmlSchemaAttribute2.FixedValue = "PrincipalDataTable";
				xmlSchemaComplexType.Attributes.Add(xmlSchemaAttribute2);
				xmlSchemaComplexType.Particle = xmlSchemaSequence;
				XmlSchema schemaSerializable = dsFrmRegionalLeader.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 RegionalLeaderRow : DataRow
		{
			private RegionalLeaderDataTable tableRegionalLeader;

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

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

			[DebuggerNonUserCode]
			internal RegionalLeaderRow(DataRowBuilder rb)
				: base(rb)
			{
				tableRegionalLeader = (RegionalLeaderDataTable)base.Table;
			}

			[DebuggerNonUserCode]
			public bool IsNo_RegionalLeaderNull()
			{
				return IsNull(tableRegionalLeader.No_RegionalLeaderColumn);
			}

			[DebuggerNonUserCode]
			public void SetNo_RegionalLeaderNull()
			{
				base[tableRegionalLeader.No_RegionalLeaderColumn] = Convert.DBNull;
			}

			[DebuggerNonUserCode]
			public bool IsName_RegionalLeaderNull()
			{
				return IsNull(tableRegionalLeader.Name_RegionalLeaderColumn);
			}

			[DebuggerNonUserCode]
			public void SetName_RegionalLeaderNull()
			{
				base[tableRegionalLeader.Name_RegionalLeaderColumn] = Convert.DBNull;
			}
		}

		[GeneratedCode("System.Data.Design.TypedDataSetGenerator", "2.0.0.0")]
		public class EmployeeRow : DataRow
		{
			private EmployeeDataTable tableEmployee;

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

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

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

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

			[DebuggerNonUserCode]
			public bool Gender_Employee
			{
				get
				{
					try
					{
						return (bool)base[tableEmployee.Gender_EmployeeColumn];
					}
					catch (InvalidCastException innerException)
					{
						throw new StrongTypingException("The value for column 'Gender_Employee' in table 'Employee' is DBNull.", innerException);
					}
				}
				set
				{
					base[tableEmployee.Gender_EmployeeColumn] = value;
				}
			}

			[DebuggerNonUserCode]
			public int Country_Employee
			{
				get
				{
					try
					{
						return (int)base[tableEmployee.Country_EmployeeColumn];
					}
					catch (InvalidCastException innerException)
					{
						throw new StrongTypingException("The value for column 'Country_Employee' in table 'Employee' is DBNull.", innerException);
					}
				}
				set
				{
					base[tableEmployee.Country_EmployeeColumn] = value;
				}
			}

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

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

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

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

			[DebuggerNonUserCode]
			public bool IsMarried_Employee
			{
				get
				{
					try
					{
						return (bool)base[tableEmployee.IsMarried_EmployeeColumn];
					}
					catch (InvalidCastException innerException)
					{
						throw new StrongTypingException("The value for column 'IsMarried_Employee' in table 'Employee' is DBNull.", innerException);
					}
				}
				set
				{
					base[tableEmployee.IsMarried_EmployeeColumn] = value;
				}
			}

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

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

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

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

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

			[DebuggerNonUserCode]
			public int ObJobStatus_Employee
			{
				get
				{
					try
					{
						return (int)base[tableEmployee.ObJobStatus_EmployeeColumn];
					}
					catch (InvalidCastException innerException)
					{
						throw new StrongTypingException("The value for column 'ObJobStatus_Employee' in table 'Employee' is DBNull.", innerException);
					}
				}
				set
				{
					base[tableEmployee.ObJobStatus_EmployeeColumn] = value;
				}
			}

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

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

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

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

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

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

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

			[DebuggerNonUserCode]
			internal EmployeeRow(DataRowBuilder rb)
				: base(rb)
			{
				tableEmployee = (EmployeeDataTable)base.Table;
			}

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

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

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

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

			[DebuggerNonUserCode]
			public bool IsEmployeeNo_EmployeeNull()
			{
				return IsNull(tableEmployee.EmployeeNo_EmployeeColumn);
			}

			[DebuggerNonUserCode]
			public void SetEmployeeNo_EmployeeNull()
			{
				base[tableEmployee.EmployeeNo_EmployeeColumn] = Convert.DBNull;
			}

			[DebuggerNonUserCode]
			public bool IsNameEng_EmployeeNull()
			{
				return IsNull(tableEmployee.NameEng_EmployeeColumn);
			}

			[DebuggerNonUserCode]
			public void SetNameEng_EmployeeNull()
			{
				base[tableEmployee.NameEng_EmployeeColumn] = Convert.DBNull;
			}

			[DebuggerNonUserCode]
			public bool IsGender_EmployeeNull()
			{
				return IsNull(tableEmployee.Gender_EmployeeColumn);
			}

			[DebuggerNonUserCode]
			public void SetGender_EmployeeNull()
			{
				base[tableEmployee.Gender_EmployeeColumn] = Convert.DBNull;
			}

			[DebuggerNonUserCode]
			public bool IsCountry_EmployeeNull()
			{
				return IsNull(tableEmployee.Country_EmployeeColumn);
			}

			[DebuggerNonUserCode]
			public void SetCountry_EmployeeNull()
			{
				base[tableEmployee.Country_EmployeeColumn] = Convert.DBNull;
			}

			[DebuggerNonUserCode]
			public bool IsHomeplace_EmployeeNull()
			{
				return IsNull(tableEmployee.Homeplace_EmployeeColumn);
			}

			[DebuggerNonUserCode]
			public void SetHomeplace_EmployeeNull()
			{
				base[tableEmployee.Homeplace_EmployeeColumn] = Convert.DBNull;
			}

			[DebuggerNonUserCode]
			public bool IsNation_EmployeeNull()
			{
				return IsNull(tableEmployee.Nation_EmployeeColumn);
			}

			[DebuggerNonUserCode]
			public void SetNation_EmployeeNull()
			{
				base[tableEmployee.Nation_EmployeeColumn] = Convert.DBNull;
			}

			[DebuggerNonUserCode]
			public bool IsIDNo_EmployeeNull()
			{
				return IsNull(tableEmployee.IDNo_EmployeeColumn);
			}

			[DebuggerNonUserCode]
			public void SetIDNo_EmployeeNull()
			{
				base[tableEmployee.IDNo_EmployeeColumn] = Convert.DBNull;
			}

			[DebuggerNonUserCode]
			public bool IsPassport_EmployeeNull()
			{
				return IsNull(tableEmployee.Passport_EmployeeColumn);
			}

			[DebuggerNonUserCode]
			public void SetPassport_EmployeeNull()
			{
				base[tableEmployee.Passport_EmployeeColumn] = Convert.DBNull;
			}

			[DebuggerNonUserCode]
			public bool IsIsMarried_EmployeeNull()
			{
				return IsNull(tableEmployee.IsMarried_EmployeeColumn);
			}

			[DebuggerNonUserCode]
			public void SetIsMarried_EmployeeNull()
			{
				base[tableEmployee.IsMarried_EmployeeColumn] = Convert.DBNull;
			}

			[DebuggerNonUserCode]
			public bool IsCreateDate_EmployeeNull()
			{
				return IsNull(tableEmployee.CreateDate_EmployeeColumn);
			}

			[DebuggerNonUserCode]
			public void SetCreateDate_EmployeeNull()
			{
				base[tableEmployee.CreateDate_EmployeeColumn] = Convert.DBNull;
			}

			[DebuggerNonUserCode]
			public bool IsDuty_EmployeeNull()
			{
				return IsNull(tableEmployee.Duty_EmployeeColumn);
			}

			[DebuggerNonUserCode]
			public void SetDuty_EmployeeNull()
			{
				base[tableEmployee.Duty_EmployeeColumn] = Convert.DBNull;
			}

			[DebuggerNonUserCode]
			public bool IsProbation_EmployeeNull()
			{
				return IsNull(tableEmployee.Probation_EmployeeColumn);
			}

			[DebuggerNonUserCode]
			public void SetProbation_EmployeeNull()
			{
				base[tableEmployee.Probation_EmployeeColumn] = Convert.DBNull;
			}

			[DebuggerNonUserCode]
			public bool IsOnJobDate_EmployeeNull()
			{
				return IsNull(tableEmployee.OnJobDate_EmployeeColumn);
			}

			[DebuggerNonUserCode]
			public void SetOnJobDate_EmployeeNull()
			{
				base[tableEmployee.OnJobDate_EmployeeColumn] = Convert.DBNull;
			}

			[DebuggerNonUserCode]
			public bool IsOnDuty_EmployeeNull()
			{
				return IsNull(tableEmployee.OnDuty_EmployeeColumn);
			}

			[DebuggerNonUserCode]
			public void SetOnDuty_EmployeeNull()
			{
				base[tableEmployee.OnDuty_EmployeeColumn] = Convert.DBNull;
			}

			[DebuggerNonUserCode]
			public bool IsObJobStatus_EmployeeNull()
			{
				return IsNull(tableEmployee.ObJobStatus_EmployeeColumn);
			}

			[DebuggerNonUserCode]
			public void SetObJobStatus_EmployeeNull()
			{
				base[tableEmployee.ObJobStatus_EmployeeColumn] = Convert.DBNull;
			}

			[DebuggerNonUserCode]
			public bool IsOffDuty_EmployeeNull()
			{
				return IsNull(tableEmployee.OffDuty_EmployeeColumn);
			}

			[DebuggerNonUserCode]
			public void SetOffDuty_EmployeeNull()
			{
				base[tableEmployee.OffDuty_EmployeeColumn] = Convert.DBNull;
			}

			[DebuggerNonUserCode]
			public bool IsSuspendDate_EmployeeNull()
			{
				return IsNull(tableEmployee.SuspendDate_EmployeeColumn);
			}

			[DebuggerNonUserCode]
			public void SetSuspendDate_EmployeeNull()
			{
				base[tableEmployee.SuspendDate_EmployeeColumn] = Convert.DBNull;
			}

			[DebuggerNonUserCode]
			public bool IsTel_EmployeeNull()
			{
				return IsNull(tableEmployee.Tel_EmployeeColumn);
			}

			[DebuggerNonUserCode]
			public void SetTel_EmployeeNull()
			{
				base[tableEmployee.Tel_EmployeeColumn] = Convert.DBNull;
			}

			[DebuggerNonUserCode]
			public bool IsEMail_EmployeeNull()
			{
				return IsNull(tableEmployee.EMail_EmployeeColumn);
			}

			[DebuggerNonUserCode]
			public void SetEMail_EmployeeNull()
			{
				base[tableEmployee.EMail_EmployeeColumn] = Convert.DBNull;
			}

			[DebuggerNonUserCode]
			public bool IsAddress_EmployeeNull()
			{
				return IsNull(tableEmployee.Address_EmployeeColumn);
			}

			[DebuggerNonUserCode]
			public void SetAddress_EmployeeNull()
			{
				base[tableEmployee.Address_EmployeeColumn] = Convert.DBNull;
			}

			[DebuggerNonUserCode]
			public bool IsComment_EmployeeNull()
			{
				return IsNull(tableEmployee.Comment_EmployeeColumn);
			}

			[DebuggerNonUserCode]
			public void SetComment_EmployeeNull()
			{
				base[tableEmployee.Comment_EmployeeColumn] = Convert.DBNull;
			}

			[DebuggerNonUserCode]
			public bool IsLastModDate_EmployeeNull()
			{
				return IsNull(tableEmployee.LastModDate_EmployeeColumn);
			}

			[DebuggerNonUserCode]
			public void SetLastModDate_EmployeeNull()
			{
				base[tableEmployee.LastModDate_EmployeeColumn] = Convert.DBNull;
			}
		}

		[GeneratedCode("System.Data.Design.TypedDataSetGenerator", "2.0.0.0")]
		public class PrincipalRow : DataRow
		{
			private PrincipalDataTable tablePrincipal;

			[DebuggerNonUserCode]
			public bool IsMain_Principal
			{
				get
				{
					try
					{
						return (bool)base[tablePrincipal.IsMain_PrincipalColumn];
					}
					catch (InvalidCastException innerException)
					{
						throw new StrongTypingException("The value for column 'IsMain_Principal' in table 'Principal' is DBNull.", innerException);
					}
				}
				set
				{
					base[tablePrincipal.IsMain_PrincipalColumn] = value;
				}
			}

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

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

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

			[DebuggerNonUserCode]
			internal PrincipalRow(DataRowBuilder rb)
				: base(rb)
			{
				tablePrincipal = (PrincipalDataTable)base.Table;
			}

			[DebuggerNonUserCode]
			public bool IsIsMain_PrincipalNull()
			{
				return IsNull(tablePrincipal.IsMain_PrincipalColumn);
			}

			[DebuggerNonUserCode]
			public void SetIsMain_PrincipalNull()
			{
				base[tablePrincipal.IsMain_PrincipalColumn] = Convert.DBNull;
			}

			[DebuggerNonUserCode]
			public bool IsComment_PrincipalNull()
			{
				return IsNull(tablePrincipal.Comment_PrincipalColumn);
			}

			[DebuggerNonUserCode]
			public void SetComment_PrincipalNull()
			{
				base[tablePrincipal.Comment_PrincipalColumn] = Convert.DBNull;
			}

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

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

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

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

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

			private DataRowAction eventAction;

			[DebuggerNonUserCode]
			public RegionalLeaderRow Row => eventRow;

			[DebuggerNonUserCode]
			public DataRowAction Action => eventAction;

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

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

			private DataRowAction eventAction;

			[DebuggerNonUserCode]
			public EmployeeRow Row => eventRow;

			[DebuggerNonUserCode]
			public DataRowAction Action => eventAction;

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

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

			private DataRowAction eventAction;

			[DebuggerNonUserCode]
			public PrincipalRow Row => eventRow;

			[DebuggerNonUserCode]
			public DataRowAction Action => eventAction;

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

		private RegionalLeaderDataTable tableRegionalLeader;

		private EmployeeDataTable tableEmployee;

		private PrincipalDataTable tablePrincipal;

		private SchemaSerializationMode _schemaSerializationMode = SchemaSerializationMode.IncludeSchema;

		[Browsable(false)]
		[DebuggerNonUserCode]
		[DesignerSerializationVisibility(DesignerSerializationVisibility.Content)]
		public RegionalLeaderDataTable RegionalLeader => tableRegionalLeader;

		[DesignerSerializationVisibility(DesignerSerializationVisibility.Content)]
		[DebuggerNonUserCode]
		[Browsable(false)]
		public EmployeeDataTable Employee => tableEmployee;

		[Browsable(false)]
		[DesignerSerializationVisibility(DesignerSerializationVisibility.Content)]
		[DebuggerNonUserCode]
		public PrincipalDataTable Principal => tablePrincipal;

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

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

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

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

		[DebuggerNonUserCode]
		protected dsFrmRegionalLeader(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["RegionalLeader"] != null)
				{
					base.Tables.Add(new RegionalLeaderDataTable(dataSet.Tables["RegionalLeader"]));
				}
				if (dataSet.Tables["Employee"] != null)
				{
					base.Tables.Add(new EmployeeDataTable(dataSet.Tables["Employee"]));
				}
				if (dataSet.Tables["Principal"] != null)
				{
					base.Tables.Add(new PrincipalDataTable(dataSet.Tables["Principal"]));
				}
				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()
		{
			dsFrmRegionalLeader dsFrmRegionalLeader = (dsFrmRegionalLeader)base.Clone();
			dsFrmRegionalLeader.InitVars();
			dsFrmRegionalLeader.SchemaSerializationMode = SchemaSerializationMode;
			return dsFrmRegionalLeader;
		}

		[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["RegionalLeader"] != null)
				{
					base.Tables.Add(new RegionalLeaderDataTable(dataSet.Tables["RegionalLeader"]));
				}
				if (dataSet.Tables["Employee"] != null)
				{
					base.Tables.Add(new EmployeeDataTable(dataSet.Tables["Employee"]));
				}
				if (dataSet.Tables["Principal"] != null)
				{
					base.Tables.Add(new PrincipalDataTable(dataSet.Tables["Principal"]));
				}
				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)
		{
			tableRegionalLeader = (RegionalLeaderDataTable)base.Tables["RegionalLeader"];
			if (initTable && tableRegionalLeader != null)
			{
				tableRegionalLeader.InitVars();
			}
			tableEmployee = (EmployeeDataTable)base.Tables["Employee"];
			if (initTable && tableEmployee != null)
			{
				tableEmployee.InitVars();
			}
			tablePrincipal = (PrincipalDataTable)base.Tables["Principal"];
			if (initTable && tablePrincipal != null)
			{
				tablePrincipal.InitVars();
			}
		}

		[DebuggerNonUserCode]
		private void InitClass()
		{
			base.DataSetName = "dsFrmRegionalLeader";
			base.Prefix = "";
			base.Namespace = "http://tempuri.org/dsFrmRegionalLeader.xsd";
			base.EnforceConstraints = true;
			SchemaSerializationMode = SchemaSerializationMode.IncludeSchema;
			tableRegionalLeader = new RegionalLeaderDataTable();
			base.Tables.Add(tableRegionalLeader);
			tableEmployee = new EmployeeDataTable();
			base.Tables.Add(tableEmployee);
			tablePrincipal = new PrincipalDataTable();
			base.Tables.Add(tablePrincipal);
		}

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

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

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

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

		[DebuggerNonUserCode]
		public static XmlSchemaComplexType GetTypedDataSetSchema(XmlSchemaSet xs)
		{
			dsFrmRegionalLeader dsFrmRegionalLeader = new dsFrmRegionalLeader();
			XmlSchemaComplexType xmlSchemaComplexType = new XmlSchemaComplexType();
			XmlSchemaSequence xmlSchemaSequence = new XmlSchemaSequence();
			XmlSchemaAny xmlSchemaAny = new XmlSchemaAny();
			xmlSchemaAny.Namespace = dsFrmRegionalLeader.Namespace;
			xmlSchemaSequence.Items.Add(xmlSchemaAny);
			xmlSchemaComplexType.Particle = xmlSchemaSequence;
			XmlSchema schemaSerializable = dsFrmRegionalLeader.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;
		}
	}
}